{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"red\">注</font>: 使用 tensorboard 可视化需要安装 tensorflow (TensorBoard依赖于tensorflow库，可以任意安装tensorflow的gpu/cpu版本)\n",
    "\n",
    "```shell\n",
    "pip install tensorflow-cpu\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:16:50.110697Z",
     "start_time": "2025-01-30T13:16:50.104734Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:25:28.899122Z",
     "iopub.status.busy": "2025-01-30T14:25:28.898602Z",
     "iopub.status.idle": "2025-01-30T14:25:28.909442Z",
     "shell.execute_reply": "2025-01-30T14:25:28.908646Z",
     "shell.execute_reply.started": "2025-01-30T14:25:28.899082Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:16:53.794635Z",
     "start_time": "2025-01-30T13:16:53.739566Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:25:30.596038Z",
     "iopub.status.busy": "2025-01-30T14:25:30.595541Z",
     "iopub.status.idle": "2025-01-30T14:25:30.713859Z",
     "shell.execute_reply": "2025-01-30T14:25:30.712934Z",
     "shell.execute_reply.started": "2025-01-30T14:25:30.596002Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60000 10000\n"
     ]
    }
   ],
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "from torch.utils.data import random_split\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "print(len(train_ds), len(test_ds))\n",
    "seed = 42\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 这里用 random_split 按照 11 : 1 的比例来划分数据集\n",
    "train_ds, val_ds = random_split(train_ds, [55000, 5000], torch.Generator().manual_seed(seed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:17:01.825285Z",
     "start_time": "2025-01-30T13:16:56.033847Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:25:34.255545Z",
     "iopub.status.busy": "2025-01-30T14:25:34.255023Z",
     "iopub.status.idle": "2025-01-30T14:25:42.229088Z",
     "shell.execute_reply": "2025-01-30T14:25:42.228213Z",
     "shell.execute_reply.started": "2025-01-30T14:25:34.255508Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2856]), tensor([0.3202]))\n"
     ]
    }
   ],
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2856], [0.3202])\n",
    ") # 对每个通道进行标准化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:17:01.830258Z",
     "start_time": "2025-01-30T13:17:01.826267Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-30T14:25:42.231016Z",
     "iopub.status.busy": "2025-01-30T14:25:42.230656Z",
     "iopub.status.idle": "2025-01-30T14:25:42.237202Z",
     "shell.execute_reply": "2025-01-30T14:25:42.236306Z",
     "shell.execute_reply.started": "2025-01-30T14:25:42.230988Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([1, 28, 28]), 9)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img, label = train_ds[0]\n",
    "img.shape, label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:17:01.835239Z",
     "start_time": "2025-01-30T13:17:01.830258Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:25:42.238298Z",
     "iopub.status.busy": "2025-01-30T14:25:42.238003Z",
     "iopub.status.idle": "2025-01-30T14:25:42.243139Z",
     "shell.execute_reply": "2025-01-30T14:25:42.242331Z",
     "shell.execute_reply.started": "2025-01-30T14:25:42.238273Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from torch.utils.data.dataloader import DataLoader\n",
    "\n",
    "batch_size = 32\n",
    "# 从数据集到dataloader\n",
    "train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=4)\n",
    "val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False, num_workers=4)\n",
    "test_loader = DataLoader(test_ds, batch_size=batch_size, shuffle=False, num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:17:03.670901Z",
     "start_time": "2025-01-30T13:17:03.655461Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:31:56.405331Z",
     "iopub.status.busy": "2025-01-30T14:31:56.404813Z",
     "iopub.status.idle": "2025-01-30T14:31:56.429483Z",
     "shell.execute_reply": "2025-01-30T14:31:56.428580Z",
     "shell.execute_reply.started": "2025-01-30T14:31:56.405289Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv1.weight\tparamerters num: 800\n",
      "conv1.bias\tparamerters num: 32\n",
      "conv2.weight\tparamerters num: 25600\n",
      "conv2.bias\tparamerters num: 32\n",
      "conv3.weight\tparamerters num: 18432\n",
      "conv3.bias\tparamerters num: 64\n",
      "conv4.weight\tparamerters num: 36864\n",
      "conv4.bias\tparamerters num: 64\n",
      "conv5.weight\tparamerters num: 73728\n",
      "conv5.bias\tparamerters num: 128\n",
      "conv6.weight\tparamerters num: 147456\n",
      "conv6.bias\tparamerters num: 128\n",
      "fc1.weight\tparamerters num: 147456\n",
      "fc1.bias\tparamerters num: 128\n",
      "fc2.weight\tparamerters num: 1280\n",
      "fc2.bias\tparamerters num: 10\n"
     ]
    }
   ],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self, activation=\"relu\"):\n",
    "        super().__init__()\n",
    "        self.activation = F.relu if activation == \"relu\" else F.selu\n",
    "        #输入通道数，图片是灰度图，所以是1，图片是彩色图，就是3，输出通道数，就是卷积核的个数（32,1,28,28）\n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5, padding=1)\n",
    "        self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=1)\n",
    "        self.pool = nn.MaxPool2d(2, 2) \n",
    "        # 输入x(32,32,14,14) 输出x(32,64,14,14)，池化不改变通道数\n",
    "        self.conv3 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)\n",
    "        self.conv4 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1)\n",
    "        self.conv5 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)\n",
    "        self.conv6 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, padding=1)\n",
    "        self.flatten = nn.Flatten()\n",
    "        # input shape is (28, 28, 1) so the fc1 layer in_features is 128 * 3 * 3\n",
    "        self.fc1 = nn.Linear(128 * 3 * 3, 128)\n",
    "        self.fc2 = nn.Linear(128, 10)\n",
    "\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        act = self.activation\n",
    "        # 2层卷积1层池化\n",
    "        x = self.pool(act(self.conv2(act(self.conv1(x))))) # 1 * 28 * 28 -> 32 * 12 * 12\n",
    "        #print(x.shape)\n",
    "        x = self.pool(act(self.conv4(act(self.conv3(x))))) # 32 * 12* 12 -> 64 * 6 * 6\n",
    "        #print(x.shape)\n",
    "        x = self.pool(act(self.conv6(act(self.conv5(x))))) # 64 * 6 * 6 -> 128 * 3 * 3\n",
    "        #print(x.shape)\n",
    "        x = self.flatten(x) # 128 * 3 * 3 ->1152\n",
    "        x = act(self.fc1(x)) # 1152 -> 128\n",
    "        x = self.fc2(x) # 128 -> 10\n",
    "        return x\n",
    "\n",
    "\n",
    "for idx, (key, value) in enumerate(CNN().named_parameters()):\n",
    "    print(f\"{key}\\tparamerters num: {np.prod(value.shape)}\") # 打印模型的参数信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:07:37.284138Z",
     "start_time": "2025-01-30T13:07:37.121834Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-30T14:07:17.783686Z",
     "iopub.status.busy": "2025-01-30T14:07:17.783324Z",
     "iopub.status.idle": "2025-01-30T14:07:17.798909Z",
     "shell.execute_reply": "2025-01-30T14:07:17.798089Z",
     "shell.execute_reply.started": "2025-01-30T14:07:17.783661Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.1267,  0.0519, -0.1382, -0.0944,  0.0758,  0.0312, -0.0066,  0.1402,\n",
       "          0.0068,  0.0131]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 看看模型\n",
    "activation = \"relu\"\n",
    "model = CNN(activation)\n",
    "# model.to(device)\n",
    "img = torch.randn(1, 1, 28, 28)\n",
    "model(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:45:47.816268Z",
     "start_time": "2025-01-30T13:45:47.803556Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:07:17.800136Z",
     "iopub.status.busy": "2025-01-30T14:07:17.799773Z",
     "iopub.status.idle": "2025-01-30T14:07:17.821922Z",
     "shell.execute_reply": "2025-01-30T14:07:17.821120Z",
     "shell.execute_reply.started": "2025-01-30T14:07:17.800111Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.0489, -0.0124,  0.0284, -0.0343,  0.0548,  0.0462,  0.0672,  0.0276,\n",
       "         -0.0357,  0.0081]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 练习不同尺寸的卷积核，padding，stride的效果\n",
    "class CNN1(nn.Module):\n",
    "    def __init__(self, activation=\"relu\"):\n",
    "        super().__init__()\n",
    "        self.activation = F.relu if activation == \"relu\" else F.selu\n",
    "        #输入通道数，图片是灰度图，所以是1，图片是彩色图，就是3，输出通道数，就是卷积核的个数（32,1,28,28）\n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5,padding=2,stride=2)\n",
    "        self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=1)\n",
    "        self.pool = nn.MaxPool2d(2, 2) #池化核大小为2（2*2），步长为2\n",
    "        self.conv3 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)\n",
    "        self.conv4 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1)\n",
    "        self.conv5 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)\n",
    "        self.conv6 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, padding=1)\n",
    "        self.flatten = nn.Flatten()\n",
    "        # input shape is (28, 28, 1) so the fc1 layer in_features is 128 * 3 * 3\n",
    "        self.fc1 = nn.Linear(128, 32)\n",
    "        self.fc2 = nn.Linear(32, 10) #输出尺寸（32,10）\n",
    "\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        act = self.activation\n",
    "        x=act(self.conv1(x)) # 1 * 28 * 28 -> 32 * 14 * 14\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv2(x)) # 32 * 14 * 14 -> 32 * 14 * 14\n",
    "        #print(x.shape)\n",
    "        x = self.pool(x) # 32 * 14 * 14 -> 32 * 7 * 7\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv3(x)) # 32 * 7 * 7 -> 64 * 7 * 7\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv4(x)) # 64 * 7 * 7 -> 64 * 7 * 7\n",
    "        #print(x.shape)\n",
    "        x = self.pool(x) # 64 * 7 * 7 -> 64 * 3 * 3\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv5(x)) # 64 * 3 * 3 -> 128 * 3 * 3\n",
    "        # print(x.shape)\n",
    "        x=act(self.conv6(x)) # 128 * 3 * 3 -> 128 * 3 * 3\n",
    "        #print(x.shape)\n",
    "        x = self.pool(x) # 128 * 3 * 3 -> 128 * 1 * 1\n",
    "        #print(x.shape)\n",
    "        x = self.flatten(x) # 128 * 1 * 1 ->128\n",
    "        x = act(self.fc1(x)) # 128 -> 32\n",
    "        x = self.fc2(x) # 32 -> 10\n",
    "        return x\n",
    "\n",
    "# 看看模型\n",
    "activation = \"relu\"\n",
    "model = CNN1(activation)\n",
    "# model.to(device)\n",
    "img = torch.randn(1, 1, 28, 28)\n",
    "model(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T03:04:53.570608600Z",
     "start_time": "2024-07-23T03:04:53.551722300Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-30T14:14:18.095436Z",
     "iopub.status.busy": "2025-01-30T14:14:18.094653Z",
     "iopub.status.idle": "2025-01-30T14:14:18.117684Z",
     "shell.execute_reply": "2025-01-30T14:14:18.116836Z",
     "shell.execute_reply.started": "2025-01-30T14:14:18.095396Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv1.weight\tparamerters num: 288\n",
      "conv1.bias\tparamerters num: 32\n",
      "conv2.weight\tparamerters num: 9216\n",
      "conv2.bias\tparamerters num: 32\n",
      "conv3.weight\tparamerters num: 18432\n",
      "conv3.bias\tparamerters num: 64\n",
      "conv4.weight\tparamerters num: 36864\n",
      "conv4.bias\tparamerters num: 64\n",
      "conv5.weight\tparamerters num: 73728\n",
      "conv5.bias\tparamerters num: 128\n",
      "conv6.weight\tparamerters num: 147456\n",
      "conv6.bias\tparamerters num: 128\n",
      "fc1.weight\tparamerters num: 147456\n",
      "fc1.bias\tparamerters num: 128\n",
      "fc2.weight\tparamerters num: 1280\n",
      "fc2.bias\tparamerters num: 10\n"
     ]
    }
   ],
   "source": [
    "class CNN2(nn.Module):\n",
    "    def __init__(self, activation=\"relu\"):\n",
    "        super().__init__()\n",
    "        self.activation = F.relu if activation == \"relu\" else F.selu\n",
    "        #输入通道数，图片是灰度图，所以是1，图片是彩色图，就是3，输出通道数，就是卷积核的个数（32,1,28,28）\n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1)\n",
    "        #输入x(32,32,28,28) 输出x(32,32,28,28)\n",
    "        self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=1)\n",
    "        self.pool = nn.MaxPool2d(2, 2) #池化核大小为2（2*2），步长为2\n",
    "        self.conv3 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)\n",
    "        self.conv4 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1)\n",
    "        self.conv5 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)\n",
    "        self.conv6 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, padding=1)\n",
    "        self.flatten = nn.Flatten()\n",
    "        # input shape is (28, 28, 1) so the fc1 layer in_features is 128 * 3 * 3\n",
    "        self.fc1 = nn.Linear(128 * 3 * 3, 128)\n",
    "        self.fc2 = nn.Linear(128, 10) #输出尺寸（32,10）\n",
    "\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        act = self.activation\n",
    "        x=act(self.conv1(x)) # 1 * 28 * 28 -> 32 * 28 * 28\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv2(x)) # 32 * 28 * 28 -> 32 * 28 * 28\n",
    "        #print(x.shape)\n",
    "        x = self.pool(x) # 32 * 28 * 28 -> 32 * 14 * 14\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv3(x)) # 32 * 14 * 14 -> 64 * 14 * 14\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv4(x)) # 64 * 14 * 14 -> 64 * 14 * 14\n",
    "        #print(x.shape)\n",
    "        x = self.pool(x) # 32 * 14 * 14 -> 64 * 7 * 7\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv5(x)) # 64 * 7 * 7 -> 128 * 7 * 7\n",
    "        #print(x.shape)\n",
    "        x=act(self.conv6(x)) # 128 * 7 * 7 -> 128 * 7 * 7\n",
    "        #print(x.shape)\n",
    "        x = self.pool(x) # 128 * 7 * 7 -> 128 * 3 * 3\n",
    "        #print(x.shape)\n",
    "        x = self.flatten(x) # 128 * 3 * 3 ->1152\n",
    "        x = act(self.fc1(x)) # 1152 -> 128\n",
    "        x = self.fc2(x) # 128 -> 10\n",
    "        return x\n",
    "\n",
    "\n",
    "for idx, (key, value) in enumerate(CNN().named_parameters()):\n",
    "    print(f\"{key}\\tparamerters num: {np.prod(value.shape)}\") # 打印模型的参数信息\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T03:05:30.672068100Z",
     "start_time": "2024-07-23T03:05:30.645081600Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-30T14:07:44.803537Z",
     "iopub.status.busy": "2025-01-30T14:07:44.803042Z",
     "iopub.status.idle": "2025-01-30T14:07:44.815865Z",
     "shell.execute_reply": "2025-01-30T14:07:44.815078Z",
     "shell.execute_reply.started": "2025-01-30T14:07:44.803503Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "activation = \"relu\"\n",
    "model = CNN2(activation)\n",
    "# model.to(device)\n",
    "# img = torch.randn(1, 1, 28, 28)\n",
    "# model(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:13:41.137264Z",
     "start_time": "2025-01-30T13:13:41.131190Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-30T14:07:48.553295Z",
     "iopub.status.busy": "2025-01-30T14:07:48.552813Z",
     "iopub.status.idle": "2025-01-30T14:07:48.561432Z",
     "shell.execute_reply": "2025-01-30T14:07:48.560741Z",
     "shell.execute_reply.started": "2025-01-30T14:07:48.553263Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv1 - 288\n",
      "conv2 - 9216\n",
      "conv3 - 18432\n",
      "conv4 - 36864\n",
      "conv5 - 73728\n",
      "conv6 - 147456\n",
      "fc1 - 147456\n",
      "fc2 - 1280\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "435306"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 练习计算参数量\n",
    "print(f'conv1 - {1*3*3*32}') # 32个卷积核，每个卷积核大小为1*3*3\n",
    "print(f'conv2 - {32*3*3*32}') # 32个卷积核，每个卷积核大小为32*3*3\n",
    "print(f'conv3 - {32*3*3*64}')\n",
    "print(f'conv4 - {64*3*3*64}')\n",
    "print(f'conv5 - {64*3*3*128}')\n",
    "print(f'conv6 - {128*3*3*128}')\n",
    "print(f'fc1 - {1152*128}')\n",
    "print(f'fc2 - {128*10}')\n",
    "\n",
    "#对上面求和，总参数数目为：\n",
    "1*3*3*32 +32+ 32*3*3*32 +32+ 32*3*3*64 +64+ 64*3*3*64+64 + 64*3*3*128 +128+ 128*3*3*128 +128+ 128*3*3*128+128 + 128*10+10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练\n",
    "\n",
    "pytorch的训练需要自行实现，包括\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义训练步\n",
    "4. 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:17:31.382339Z",
     "start_time": "2025-01-30T13:17:31.378283Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:25:50.045639Z",
     "iopub.status.busy": "2025-01-30T14:25:50.045136Z",
     "iopub.status.idle": "2025-01-30T14:25:50.052502Z",
     "shell.execute_reply": "2025-01-30T14:25:50.051780Z",
     "shell.execute_reply.started": "2025-01-30T14:25:50.045605Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)              # 验证集预测\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item()) # 将验证集损失加入列表\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist()) # 将验证集预测结果加入列表\n",
    "        label_list.extend(labels.cpu().numpy().tolist())# 将验证集真实标签加入列表\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list) # 计算验证集准确率\n",
    "    return np.mean(loss_list), acc # 返回验证集损失均值和准确率\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:17:31.983122Z",
     "start_time": "2025-01-30T13:17:31.978208Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:25:51.240219Z",
     "iopub.status.busy": "2025-01-30T14:25:51.239735Z",
     "iopub.status.idle": "2025-01-30T14:25:51.247120Z",
     "shell.execute_reply": "2025-01-30T14:25:51.246359Z",
     "shell.execute_reply.started": "2025-01-30T14:25:51.240185Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:17:33.142490Z",
     "start_time": "2025-01-30T13:17:33.137901Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:26:04.268103Z",
     "iopub.status.busy": "2025-01-30T14:26:04.267609Z",
     "iopub.status.idle": "2025-01-30T14:26:04.274009Z",
     "shell.execute_reply": "2025-01-30T14:26:04.273195Z",
     "shell.execute_reply.started": "2025-01-30T14:26:04.268068Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:17:33.829160Z",
     "start_time": "2025-01-30T13:17:33.816751Z"
    },
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:26:12.431296Z",
     "iopub.status.busy": "2025-01-30T14:26:12.430533Z",
     "iopub.status.idle": "2025-01-30T14:26:12.450460Z",
     "shell.execute_reply": "2025-01-30T14:26:12.449744Z",
     "shell.execute_reply.started": "2025-01-30T14:26:12.431259Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "activation = \"relu\"\n",
    "model = CNN1(activation)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(f\"checkpoints/cnn-{activation}\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10,min_delta = 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:31:32.773281Z",
     "start_time": "2025-01-30T13:17:35.784633Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-30T14:08:08.924522Z",
     "iopub.status.busy": "2025-01-30T14:08:08.924013Z",
     "iopub.status.idle": "2025-01-30T14:11:42.138539Z",
     "shell.execute_reply": "2025-01-30T14:11:42.137322Z",
     "shell.execute_reply.started": "2025-01-30T14:08:08.924486Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 34380/34380 [03:33<00:00, 161.25it/s, epoch=19]\n"
     ]
    }
   ],
   "source": [
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=1000\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:34:43.226200Z",
     "start_time": "2025-01-30T13:34:43.046098Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:12:30.119534Z",
     "iopub.status.busy": "2025-01-30T14:12:30.118985Z",
     "iopub.status.idle": "2025-01-30T14:12:30.483164Z",
     "shell.execute_reply": "2025-01-30T14:12:30.482417Z",
     "shell.execute_reply.started": "2025-01-30T14:12:30.119493Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzoAAAHACAYAAABqJx3iAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA2ohJREFUeJzs3Xl8lPW1+PHPM3v2DZJASNgEBFkEFApWRUVRqnVtrXirdrHtvXpvW+qvrfe2WvVWbxeXtrb1ttbaesXaRa0VVBCLK4KAIPtOEkL2PZl95vn98cwzM0lmkplkwmQy5/165QUzmXnmO5PtOXPO9xxFVVUVIYQQQgghhBhFDMlegBBCCCGEEEIkmgQ6QgghhBBCiFFHAh0hhBBCCCHEqCOBjhBCCCGEEGLUkUBHCCGEEEIIMepIoCOEEEIIIYQYdSTQEUIIIYQQQow6EugIIYQQQgghRh1TshcQC7/fz6lTp8jJyUFRlGQvRwgh0oaqqnR2djJ+/HgMBnlvTCd/l4QQInli/duUEoHOqVOnKC8vT/YyhBAibVVXVzNhwoRkL2PEkL9LQgiRfAP9bUqJQCcnJwfQnkxubm7c9/d4PKxfv57LLrsMs9mc6OUNK1l7csjak0PWPvJ0dHRQXl4e/D08Er399tv85Cc/Yfv27dTW1vLiiy9yzTXX9HufTZs2sXr1avbu3Ut5eTnf+973uO2222J+zHT+uwSpvX5Ze3LI2pMjldfen1j/NqVEoKOXBeTm5g76D0pmZia5ubkp90WWtSeHrD05ZO0j10guz+ru7mbevHl88Ytf5Lrrrhvw9sePH+dTn/oUX/va13j22WfZuHEjX/7ylxk3bhwrVqyI6THT+e8SpPb6Ze3JIWtPjlReeywG+tuUEoGOEEIIEc0VV1zBFVdcEfPtn3jiCSZPnszDDz8MwMyZM3n33Xd59NFHYw50hBBCjHyys1QIIURa2bx5M8uXL+9x3YoVK9i8eXOSViSEEGI4SEZHCCFEWqmrq6OkpKTHdSUlJXR0dOBwOMjIyOhzH5fLhcvlCl7u6OgAtLIQj8cT9xr0+wzmviNBKq9f1p4csvbkSOW19yfW5yOBjhBi0FRVxev14vP5EnI8j8eDyWTC6XQm7JinS6qu3Wg0YjKZRvQenJHgoYce4r777utz/fr168nMzBz0cTds2DCUZSVdKq9f1p4csvbkSOW1R2K322O6nQQ6QohBcbvd1NbWxvzLJhaqqlJaWkp1dXXKnXin8tozMzMZN24cFosl2Us5LUpLS6mvr+9xXX19Pbm5uRGzOQB33303q1evDl7WO/5cdtllg25GsGHDBi699NKU3CCcyuuXtSeHrD05Unnt/dGz6gORQEcIETe/38/x48cxGo2MHz8ei8WSkJN7v99PV1cX2dnZKTecMhXXrqoqbrebxsZGjh8/zrRp01Jm7UOxZMkS1q1b1+O6DRs2sGTJkqj3sVqtWK3WPtebzeYhnTwM9f7Jlsrrl7Unh6w9OVJ57ZHE+lwk0BFCxM3tduP3+ykvLx9S2U5vfr8ft9uNzWZLuRPuVF17RkYGZrOZysrK4PpTTVdXF0eOHAlePn78ODt37qSwsJCKigruvvtuampq+OMf/wjA1772NR5//HG+/e1v88UvfpE333yTP//5z6xduzZZT0EIIcQwSJ2/xkKIESeVTuhFdKn+ddy2bRvz589n/vz5AKxevZr58+dzzz33AFBbW0tVVVXw9pMnT2bt2rVs2LCBefPm8fDDD/Pkk09Ka2khhBhlJKMjhBAipS1btgxVVaN+/umnn454n48++mgYVyWEECLZUvttPCGEEEIIIYSIQAIdIYQYpEmTJvHYY48l5FibNm1CURTa2toScjwhhBAi3UnpmhAirSxbtoyzzz47IQHKhx9+SFZW1tAXJYQQQoiEk0BHCCHCqKqKz+fDZBr41+PYsWNPw4qEEEIIMRijvnRtx7bN/Pmnd1C375/JXooQo5aqqtjd3oR8ONy+uG7f3yb03m677Tbeeustfvazn6EoCoqi8PTTT6MoCq+++ioLFy7EarXy7rvvcvToUa6++mpKSkrIzs7m3HPP5Y033uhxvN6lawUFBTz55JNce+21ZGZmMm3aNF5++eVBv65/+9vfOOuss7BarUyaNImHH364x+d/9atfMW3aNGw2GyUlJdxwww3Bz/31r39lzpw5ZGRkUFRUxPLly+nu7h70WoQQPe2qbuNfntzCnpr2YTn+/7x6gP96cXdcv+NEyONvHubuFz7G50+91+//PqjkP577CLfXn/Bjd7u8fO2Z7bz40cmEHzsSVVV56NX9/Pcr+5LyvTzqMzqG1qPc7HqevZyR7KUIMWo5PD5m3fN6Uh573/0ryLTE9qvsZz/7GYcOHWL27Nncf//9AOzduxeA7373u/z0pz9lypQpFBQUUF1dzcqVK/nhD3+I1Wrlj3/8I1dddRUHDx6koqIi6mM88MAD/PjHP+YnP/kJv/jFL7j55puprKyksLAwrue1fft2PvvZz/KDH/yAG2+8kffff59/+7d/o6ioiNtuu41t27bxH//xHzzzzDMsXbqUlpYW3nnnHUBrp3zTTTfx4x//mGuvvZbOzk7eeecdOWESIoH+8P4J3j3SxJ+3VTO7LC+hx+50enjiraMAfO3CqZQXJm5eWTo43tTNT9cfAuAz55SzoKIgySuKXWu3m/tf2Yfb6+e6BWUsm1Gc0OO/sb+e1/bW8d6RJlacVRrz38/Bqmlz8L9vHQNgxexSzp0U39/CoRr9gY5Fq5+34E7ySoQQyZaXl4fFYiEzM5PS0lIADhw4AMD999/PpZdeGrxtYWEh8+bNC15+4IEHePHFF3n55Ze58847oz7Grbfeyk033QTAgw8+yM9//nO2bt3K5ZdfHtdaH3nkES655BK+//3vAzB9+nT27dvHT37yE2677TaqqqrIysriyiuvJCcnh4kTJwbnyNTW1uL1ernuuuuYOHEiAHPmzInr8YUQ/dsdyORUNtsTfuzwY1a12CXQidNzW0Nzs/bUtKdUoPO3HSeDmZyqlsR/b1UFvrc6XV5e2VXLZ88tT/hjhAvPeK7ZUiWBTqIZrdovBxuuJK9EiNErw2xk3/1DH7bo9/vp7OgkJzcn5iGWGWbjkB8X4Jxzzulxuaurix/84AesXbs2GDg4HI4egycjCQ8osrKyyM3NpaGhIe717N+/n6uvvrrHdeeddx6PPfYYPp+PSy+9lIkTJzJlyhQuv/xyLr/88mDJ3Lx587jkkkuYM2cOK1as4LLLLuOGG26goCB1/tgLMZJ1u7wcaewCoHoYTkbDj1nVYue8hD/C6OXy+vjLturg5Y9PDk9p4XBQVZU1W0J/Y6qGIYgOD56e3VI57IFO+Ou/dnct91w5i4Isy7A+ZrhRv0fHaNUyOjZVAh0hhouiKGRaTAn5yLAY47q9oigJeQ69u6fdddddvPjiizz44IO888477Ny5kzlz5uB2958dNpvNfV4bvz/xddY5OTns2LGD5557jnHjxnHPPfcwb9482traMBqNbNiwgVdffZVZs2bxi1/8ghkzZnD8+PGEr0OIdLT3VAd6JejJVkfC94FU9Qp0ROxe21NHq92D/qdhdwoFOpuPNXOsKbSXsnI4Mjphx9x1sn3Y9pjp9MynooDb6+dvO07P3iDdqA90TNZsQDI6QgiNxWLB5/MNeLv33nuP2267jWuvvZY5c+ZQWlrKiRMnhn+BATNnzuS9997rs6bp06djNGpZLJPJxPLly/nxj3/Mxx9/zIkTJ3jzzTcBLcA677zzuO+++/joo4+wWCy8+OKLp239Qoxmu8NODt0+P3UdzoQeP/wEdzje1R/Nng1kRD53rraX8nBDJw73wL/zRwI9mzOpSKtGGo5soR7o6I+xZmv/VQpDoapq8GdF/3qs2VJ1WveLjv5AJyOQ0ZE9OkIItE5pW7Zs4cSJEzQ1NUXNtkybNo0XXniBnTt3smvXLlatWjUsmZlovvWtb7Fx40YeeOABDh06xB/+8Acef/xx7rrrLgBeeeUVfv7zn7Nz504qKyv54x//iN/vZ8aMGWzZsoUHH3yQbdu2UVVVxQsvvEBjYyMzZ848besXYjTbfbKtx+VEByO9S9dEbI40dLL1eAtGg8LXL5lGcY4Vvwr7akd+Vqepy8Xre+sAuGvFDED72icyKHB6fMGgXH+Mv39UQ5fLm7DHCHey1UGb3YPFaODbK2aQZTFyrKmbzceah+XxIhn1gY7ZpgU6ZsUHPgl2hEh3d911F0ajkVmzZjF27Nioe24eeeQRCgoKWLp0KVdddRUrVqxgwYIFp22dCxYs4M9//jN/+tOfmD17Nvfccw/3338/t912GwD5+fm88MILXHzxxcycOZMnnniC5557jrPOOovc3FzefvttVq5cyfTp0/ne977Hww8/zBVXXHHa1i/EaPZx4F1qm1k7japqSWzr9vBmBJXN0hY+Vmu2aHtzLj6zmNI8G3MC3fBSYZ/OX7adxONTmVeez6WzSlAUsLt9NHUl7tz1ZKsDVYUsi5GVs8cxZUwW3W4ff99Zk7DHCKe/7jNKcyjIsnDN/DKAHvuQhtuob0ZgzsgO/l9128EmU8yFSGfTp09n8+bNPa7Tg4dwkyZNCpaB6e64444el3uXsrW2tpKbm9vjura2tpjWtWzZsj7v3F1//fVcf/31EW//yU9+kk2bNkX83MyZM3nttddielwhRHw6nR6OB/ZRXHxmMet21yU06+L1+alpcwQvdzi9tNs95GWa+7mXcHp8/HW7FuisWqyVSc2ZkMfGAw0jfp+O368GO8XdvLgCq8nI+LwMatocVLXYGZtjTcjj6JnCiqIsDAaFVYsr+O+1+1mzpYpViyoStudV93FNG6B9HUD7ujy7pYrX99bR1OViTHZinld/Rn1Gx2qx4VW1p+lxyrsiQgghhBg8vRHB+Dwb88u1ToaJbDF9qs2Jz69iMRmCJ4KVCc4YjUZrP66lw+llQkEGF0wbC8DcwAn27mHecD9U7x5poqrFTo7NxFVzxwNQXpgBJDZbqGcHKwLHvn7BBCwmA3tPdQxL1ktvdDA3kFk7a3we88rz8fhU/rLt9DQlGP2BjtmIHe0XhQQ6Qohk+drXvkZ2dnbEj6997WvJXp4QIkZ6dmDOhLzgfJtEbhrXs0PlBRnBDeOyT2dg+qb6mxZVYDRomQl9kOuRxi66h2kfSiLopVzXzS8jw6I1m5lYqFUgVTU7ot4vXlUt2rEmFmnHLsiy8Kk54wCt1XQiqaoaDJ7CB+revEjLtj23tQp/grsVRjLqAx2L0YAzEOh4nV1JXo0QIl3df//97Ny5M+LH/fffn+zliVHG6fHh9Z2+5hmxsru9w3Zy4/erdDg9w3LscHp2YO6EfCYOQyCiH6uiMJOKQCDVX8aops3B0cauHh+n43UYSQ7UdbC9shWTQeEz50wIXl+cY6M014aqapm4WPj9akxBUbvDk5Dv5foOJxv21wOwavHE4PUVge+tRGbzgkF02ABavczvH7tqE/p9U9lsp9PpxWIyML0kJ3j9lfPGkWMzUdVi590jTQl7vGhG/R4dg0HBEQx0JKMjhEiO4uJiiouLk70MkQacHh+f+vk7qCqs/+YFmIwj4z3Nfac6uPIX73DLkkn84NNnJfz43/rLLtZ+XMvr37yAyWOGbz+uHujMKQtldFrtHjqcHnJtQ99Ho5/YTizKIj+wLydaxuj37x3nvn/s63N9psXIP+9aRkmubcjrSQV6RuSys0oozun5nOdMyKNun5PdNe0smlw44LHu+usuXt9Tx4t3nNfjBD3ce0ea+PzvtvDl86fwnyuH1s3ypY9q8PlVzplYwIzS0ONVDEu2MPC9FRbonDOxgOkl2Ryq7+LFHTXcunRSQh5L/zmZOS4Xiyn0OyjTYuK6+WX8YXMla7ZUccH0sQl5vGhGxm+/YebSAx2XpH6FEEKMbut213K0sZtjTd202kfOO/tbjzfjV7USmeauxM+2217Zitvn553DjQk/tq4jrBHBnLI8sq0mxmRrU94T1WK6Ouxdd/1kN1rGaOP+BkALbPIyzORlmDEZFOxuHx+cxha+yWR3e3lxh9Y1bNWiiX0+r3de690SPJq3DzXS7fbx+/dORL3NE28dxa/CM5srh5wFOdaofT/1PuGPJZsXD1VVe2QLdYqisGpR4mfchN4QyO3zuVWLJxKoLhz28rW0CHScihbd+1xSuiaEEGJ0C2/d2jmCSpjqO7XgxuNT+ev2xG9EbunW2vAOZythfXP1hIIMCrK0AKd8gGAkXvqJ7cQBStfChzH++atL2HXvZey69zJuDpQipUJL5UT4x65TdLq8TCzKZOnUoj6f1zt+fRxDQ4JulzfYzvnlnZHny1Q2d/POYa3kyuHx8dJHQ2vN3Bz4vi0KBMw6/Wvf0OlKyMDTxi43To8fgwLj8zN6fO7aBROwmQ0crO9kR1XrkB8L4ONAYDm3LL/P52aU5rDlP5fzxOcXYjAkttNbb2kR6LgVLaPjk4yOEEKIUexgXSfbKkMnKsM1CHAw6gODCkHbOJ7Id3JdXl/wue4Zxg5beiMCvZsXhMqAEhHoqKoazAxVFGUG92nUtjtwe3vuuapucdDu0IYxhpdYzZmQr611hHcaSxQ9sF+1qCLiSbOe0Tne1D1g4F/dGvoadrsjBzHPbdVaWOszlJ79YGhZkJZu7Q2AoqyegU5+ppkcm6nPugZLzxSOz8/oUUoGkJdhDnZ7ezYBM278fpW9NdqeqDlhPyvhEtUyeyDpEegYtBfT75ZARwghxOi1plfnpE7nyAl0GjpC5WqVzXbeP5q40qrW7tAJ7KH6zoS8Ax6JHjyEd5FKZIlRm91DZyBgKy/IZGy2lQyzEb9Kj9k6EJpRMnNcTo8TV/3Efm9NO77T0NUqmfbUtLPrZDsWo4EbFk6IeJsx2VbG58XWkKD317B3KZfb6+cv27RA54GrZyckC6KXlxZm9TzxVxQlVLqYgO8tveNaeNlaOL0pwSsf19JmH9qQ0hPN3XS6vFhNBqYVZw98h2GUJoGOlqJTPRLoCCGEGJ3sbi8vBN6B1t9tHkmlaw2dWkbnjMCJz5qtiWtn29wdCqL8KuyrHZ5sRrDjWlg5TkWgVW8iNo3rWaHiHCsZFmPPk91exw9vcx1u6tgsMsxGut0+jjeN7pJ9PfuwYnYpRf0Mn9Rfo4EGh+pfw/OnjcFiMrCvtoNdYffZsL+B5m43JblWrp1flpAsiL5frTCrbyOLRHb107NC+jF7O7s8n5njcnF7/fxtx9DK8fSfk1njc5PeDCUtAh1PIKOjSkZHCDFEkyZN4rHHHovptoqi8NJLLw3reoTQvbKrlk6nl4rCTBZN1vYqdIygjE59IKPzH5dMA2D93vpg8DNU+v4c3UAntIPRbvcE3/GfEyGjk4iT0cqWviejwT1AzT07x4Z3fwtnMho4a3xuj9uMRl0uLy/v1E7I9X1J0cyNsZwv/Ot7pT5f5oNQQP6nD7Vszo3nVmAyGoacBfH4/MGf0d4ZHUjs/i89o1MeJaOjKErwdVyzpXJI5XjBEs+yyGVrp1OaBDqBjI4EOkIIIUapZ8MGJuYGavu7Rkig4/T4aHdo2aULp49lQUU+Xn/ipqP3DnRi2Xgerz2ntGNWFGaSlxl6910PSmraHHiGOLuoOsKck0jv6vv9aligk9/nOHpp3WhuSPDSRzV0u31MHZvF4gHaRuuvx0CBTlVYoBmcL/PxKTocHuod8MHxVgwKfO7cckDLgswaQhakNRAcGRRtn0xvwaGhCcnoOHocM5Krzx5PpsXI0cZuthxvGfRjfRyhxDNZ0iLQ8Rq1rmuKlK4JIYQYhfbUtLOrug2zURuYmBOY5zJS9ujo+3NsZgO5NhM3BwYjPre1KiH7SPRAJ8eqBXjDkdH5OEqp2NhsK1aTAZ9fpbZtaBmqqmDHtdDJaKQ9QFWt2jBGq8nAtJK+eyDmxliqlapUVQ02IbhpUQWK0n/nrvCGBP21gw4fqLkwMF/G6fHz9121vF+vnTJffGZxsGuZoijBgGgwWRD9+zY/04IxQiOF0Nd+6HMgqyO0lu4tx2bm6rO1crw1gyzH0xoRhIbqJltaBDo+Y+Ab0usY4JZCiEFRVXB3J+bDY4/v9nH8YfnNb37D+PHj8ft7vut69dVX88UvfpGjR49y9dVXU1JSQnZ2Nueeey5vvPFGwl6m3bt3c/HFF5ORkUFRURFf+cpX6OoK1dBv2rSJRYsWkZWVRX5+Pueddx6VlVrZxK5du7jooovIyckhNzeXhQsXsm3btoStTaS2NYFszoqzShmTbQ1mdEbKHp36QIlaSa4NRVH41Nxx5GWYOdnq4O0EzL3RTxjPO2MMAEcbu2Kabh+P3YHN/73LcQwGJZiBGeoUe/3+FUWh9r8VETI6ewIdrWaOy8UcYQ+EHujsPdUxKhsS7DrZzr7aDiym6E0IwhVmWZhQoL2m0bry+fwqJ4P7WLICpVxaQP7s1mq2NmqByKpeZXJDyYK0BFpZF/bquKbTs3nVrY4hdSl0+bT20hD6fopGn0X06p7aQc27OtbUTbfbR4bZyNSxwze4N1amZC/gdPBJRkeI4eWxw4Pjh3wYA5Af753+8xRYYvtl+pnPfIZ///d/55///CeXXHIJAC0tLbz22musW7eOrq4uVq5cyQ9/+EOsVit//OMfueqqqzh48CAVFf3XgA+ku7ubFStWsGTJEj788EMaGhr48pe/zJ133snTTz+N1+vlmmuu4fbbb+e5557D7XazdevW4DuVN998M/Pnz+fXv/41RqORnTt3YjYPfQq7SH1dLi9/DzQh0E/CcoKBzsjI6OitpUsCU+ttZiPXL5jAU+8dZ82WKi6aUTyk4+uBzozSHHZWt1HX4WRfbQfnTuq/pCke0fbEgNZi+khD15BLjKojdMYK3wOkZwz2BLqHzY3SunfymGwyLUbsbh9HG7t6tJ8eDfR9M1fOGUd+ZuQgobc5ZXmcbHWw+2Q7S6eO6fP52nYHHp+K2ahQmqt9n14zv4yHXt3P0cZuQGF8no0Lp/f8XtWyIGU8t7WKNVuq+MSUvrN8ommx9x/ojMuzYTQouL1+6judjMvLiHi7gTQH4hV9qGx/5kzIY+6EPD4+2c5ft5/kqxdOjeux9DcERkIjAkiTjI7fpP2SMEhGR4i0VlBQwBVXXMGaNWuC1/31r39lzJgxXHTRRcybN4+vfvWrzJ49m2nTpvHAAw8wdepUXn755SE/9po1a3A6nfzxj39k9uzZXHzxxTz++OM888wz1NfX09HRQXt7O1deeSVTp05l5syZ3HrrrcEAq6qqiuXLl3PmmWcybdo0PvOZzzBv3rwhr0ukvpd3nqLb7WPKmCyWBE6ysgMlXCNljo5eujY2N7ThetVibZ/DmwcaqG0f2t9nPdApzLIMy/6U1m53MAg5K0KgUx5HG2CPz8+fP6ymsbPnu+Uur49T7XqgE3rzZkJBBooCdrcv+Dx36zNKouyBMBoUZo+P73WobrHzwo6Twz6pfqA1vLzrVL8lYO0OD//4+BTQN7vSn4EGhwbL1goyg2VkeRlmPj0v9CbeZ8+ZELHETN/E/9qeOn72xmF+sTH08eaB+qhrCn7fRgnWTEYDZYEyuVi+t061Ofj7zpo+X8Nmp7bm/srWwq1apD2f5wYx7ypY4jkC9udAmmR0/Gbtm8QogY4Qw8OcqWVWhsjv99PR2UluTg4GQ4zvw5hj+8Wtu/nmm7n99tv51a9+hdVq5dlnn+Vzn/scBoOBrq4ufvCDH7B27Vpqa2vxer04HA6qqoY+QG3//v3MmzePrKzQCcx5552H3+/n4MGDXHDBBdx2222sWLGCSy+9lOXLl/PZz36WceO0zj+rV6/my1/+Ms888wzLly/nM5/5DFOnxvdOmxidXt1TC8DnFpUHM4D6Hp3+9iOcTsHStUBGB+CM4hwWTS5k6/EW1n5cy5fPnzLo4zeHBTpzJ+Txxv76hA4O3VerBRYTizIjbxqPow3wb94+xk9eP8iF08fyhy8uCl5f0+pAVSHTYmRMdujE12oyMi7Xxql2J1WtDvwq7K3tfxij/rmtJ1rYfbJtwPIuVVX52v9tZ++pDtxeP59bNLQM9mCoqsoXn/6Qww1dFGVZgmWIvW062IDT42dacTYLJxbEfHy9JXi0fUuRGkEArFo8kT9vO4kBlRsWRK5cmF0WyoI8+sahHp8zKPDhfy2P2P66WS9dy46elZpYlElVi53KFjuLB8gW/ffafazbXUe7w8MtSyYFr28KbB0bqGxNd9W88Tzwyj5ONNvZX9fBWeNjD1p2j7BAJz0yOoE9OgZfYtpYCiF6URStfCwRH+bM+G4/wCbU3q666ipUVWXt2rVUV1fzzjvvcPPNNwNw11138eKLL/Lggw/yzjvvsHPnTubMmYPbPbThabH6/e9/z+bNm1m6dCnPP/8806dP54MPPgDgBz/4AXv37uVTn/oUb775JrNmzeLFF188LesSI1tNoJtSePetkVa6pmd0SnJ7nuxdOH0sMPTsS2sg0CnKsoTeuT/ZNqRjhtMbAUwdG3n4Yawtpn1+NVh29dahxh7v0leGbRbvvbk+1GbYQaMTul0+bGYDZ0RZD4RONGNpMb2zui04TPP/eg2dPV22HG/hcIO2Z/FAXWfU2x1r1PYxnTOpYMAmBOH016OqxU67ve8bAPrXuHfW4+zyfP7n2rP44gw/Jbm2PvfT/fiGudyyZCI3LaoIfmRbTfhVONka+Y12vetaUZTSNQh97WOZ06S/Nv/3Qc/GCPFmdLKsJqYG5l2diqPBhs+vBr+P5pVLoHP6BDI6Jp9kdIRIdzabjeuuu45nn32W5557jhkzZrBgwQIA3nvvPW677TauvfZa5syZQ2lpKSdOnEjI486cOZNdu3bR3R3arPzee+9hMBiYMWNG8Lr58+dz99138/777zN79uweZXbTp0/nm9/8JuvXr+e6667j97//fULWJlJbcP9LWBAR6ro2QjI6HaFmBOFibfs7EL0EqCDLEjyhPdbUnbDSvWCTgCgnisGMTrO937Krtw41cKo9dOL43IehbHG0jEL48atb7FR3aSetZ43P63cPxJywhgTeAdpeh3fY2lPTkdAgMVbha+g9Myhcf69Tf/IyzcGvX6Tvt6oIM4x01y8oY05h/yVcZ5bmcv/Vs3noujnBDz1Y0L//e9MzkQX97DOaGKHrXjT64xyq72J7ZWvw+iZXz2PFojiQfY229kiONnbh8PjItBiZPCZ6EH46pUmgo31hTZLREUKgla+tXbuWp556KpjNAZg2bRovvPACO3fuZNeuXaxatapPh7ahPKbNZuPWW29lz549/POf/+Tf//3f+fznP09JSQnHjx/n7rvvZvPmzVRWVrJ+/XoOHz7MzJkzcTgc3HnnnWzatInKykree+89PvzwQ2bOnJmQtYnU1eXy0u32AVAcFkToGZ2RskdHP1kq7pXRibXtb3/8frXHO+Njsq2Mz7OhqgTb3A7VQK15JxRo13e6vLRFyBbo9JP5GYHmAH/ZVo3bq/2OCbWW7vsYwYxRq4Oqbi3QGag0aHJRFtlWEy6vP5gpiSR8z4u+rmc/GHq5bjyau1zBEkzoPzNWGUOb5Gj04K+/QCfeAKo/JTna93tDZ+TuZXrXtaJ+StdizRa6vD5aw773ng0LHOPN6EDojZNoa49Ez8zOHp8XcS9TMqRXoOOXQEcIARdffDGFhYUcPHiQVatWBa9/5JFHKCgoYOnSpVx11VWsWLEimO0ZqszMTF5//XVaWlo499xzueGGG7jkkkt4/PHHg58/cOAA119/PdOnT+crX/kKd9xxB1/96lcxGo00Nzdzyy23MH36dD772c9yxRVXcN999yVkbSJ1NQQCiGyrKdiAAEZy6VrPjE4sbX8H0u7woO+XLgiUAPV3QjsY0cqadDazMdipqzLKCempNgdvHmgA4Oc3zac4x0pTl5v1++p63C/SPoqKIm1vX3WLnZNdsQU6BoPCWeNzgf5fhxd3nMTp8TO9JJsHrpkNwMu7Tp3W/V1/3X4Sj08lw2wE+j+pD2Ze+hl8Gc3cYAaxLfpxY9zHEgs9sG+IkhVpHaDrGoS+HwYqXevd3GLt7lpau934/Gqw61qse3Qg9LMabe2R7D3ZyjTlJJ/OOQhdDTHfbzilRTMCLNoX1uyX0jUhBBgMBk6d6ts8YdKkSbz55ps9rrvjjjt6XI6nlK13CcucOXP6HF9XUlISdc+NxWLhueeei/lxRfqoDwQQvTMleuma3e3D6/Mntc2r3e2lM5BZKs7puyF7oLa/A9HLf3JspuBMmTlleby+tz4hnddUVQ1lW/o5UawozKSuw0lVi52zy/P7fP5PH1bjV+ETUwqZUZrDjeeW84s3j7BmSxVXzh3fb9YofGhoe+B8t79GBLq5E/LYcryF3Sfb+ew55RGfmz6D6ebFEzl3UgFnFGdzpKGLv39Uw+fDNrQPF79f5bnAGr70yck8/s8jwbkxhl5ZAbvbGzyhH1RGJ0pHvnaHJ5iJKy9IZEZHL/9yaXPfOmqhqx6s2ZBXHpxT01/pmp5hau520+Xy9nhDI5z+u6Aiz8wZtnYcjcfZ/cp+5mW38W3jEbrIYvyhGsgoAFte6CMjX/vXZOux51XP6PRbuuZohZPb4eRWOPkhdx3bwr3WbjgM/PTrkDsByubD+PkwfoH2b0Z+jK9eYqRFoGMIBDoWf/yDj4QQQoiRqiHQzax3ABF+MtTl8sY8a2Q46NmcTIsx4knanAl5vLqnbtDZl0gbuucEJrInIqPT7vAEA7UJ/ZwElxdmsvVES8T9JV6fn+cD+3FWBYZQfm5RBb/85xHeP9rMscbQDJ7+Ah1t6KNChtkQtTFCOP11iNZSeXtlK4fqu7CZDVwzvwxFUVi1qIL7X9nHs1uq+JdPTIxrw/9gvH+0mRPNdnKsJr564RSeeOto1LkxeovvvAwzeZnxzxHTW4OfbHXQ2u0OZgD1IHNMtpWsKIHEgLoaoHoLdJyCzlroqOWzNSe4wlLF+L1tsKdvRmaTauWUZQzl66fDmImQNwHyyrWPzCLwe8j1uVmWcRSXy0nzTh/Z+WbwucHnAY8DOmqgtZJJNYd513qcca4WjC4/WID92uN8VX9Kr/45+vqNFu0xAx/LfNncZ3Jjqh8DW3dBZiFkFEJbJVR/CCc/hKaDPQ6RBdhVK6b8cVjaK6HjpPax/x+hGxVO1QKesgUw4VwoX8RwSo9Ax6qlNy2qC/x+iLVtrRBCRPHss8/y1a9+NeLnJk6cyN69e0/zikQ6irbJ32IyYDUZcHn9dDqTG+iErzHSSXM83cEiaY4wXb733p9c2+CH6+pla8U5VjIsxqi366/F9MYDDdR3uCjMsrDirBIAyvIzWDajmDcPNPD4m0ewu30oSuRgqiDTTI7VFAy4zhqfG9MeCL1Ua39tBx6fP5jx0un7OK6aOz7YNvv6BRP40WsHOFDXyY6qtrhaOPfL6wK1757HNVu1Lm/XzC8jx2amrCCDymY7lc32PoFOZXP/TSEGkpdhZvKYLI43dbO7pp0LAl3/QqWJcQ7kbD0B+1/RTuSrtwA9s/glQIkh7GpzFuSUgKsLuhvIUlxMU2qgsgb6aXb3NGiBy6vRb1MEEPiWUI1WjnuLqPKPxVw4kX3NXqbl+lk20QLOdnC2Bf4NfKh+LXjqrNU+Amu/1QQ4gXX9VBQUToEJi6jLnc2XNho4aZnMR1+/AjxdULsLanbAqY/g1A7t9Wo5qn3s+SuUzoGvvRv92AmQHoGOJewb1+uIeYq6EEJE8+lPf5rFixcHL/v9frq6usjOzsZq7VueI8RwqI+y9wW08jVXlyvp+3TqA6VGkcrWIBSUaGVZnrjfqQ8fFqorzLJQlp9BTZuDPTWDK4nTxbp3o79N43oTgs+cMwGrKRQsrVpUwZsHGnhxZw0A4/MysJj6vhmrKArlhZnBeT763puBTCzKJMdmotPp5VB9Z495KK3dbtbu1k5qb/7ExOD1eZlmrpw7nr/tOMmaLVVDC3Sc7XBgLex5AdOxf7LCkInBuhUW3gLFM2nodLJ+rzZQUx/+WVGYSWWznaoWO5/oNTemqrmbWcoJvqBUw47jUDILxp4Z13nd7LI8Tja1U3NwG7i6ofU4WSfhkwYfM3Nmg9cNpihvDKgq1O2BA69oAU797p6fL52jnfjnjIOcUmp8Bdz1egNuWzF/+871YM0J3vREXTO3/exFpphbeeqaUmg/Gfio0v51tGpZFqOFBrtKqwuKcrMZk5cduN4MJqv2WPkVvFxl5um9fpaes4C7rj2f3760l+e2VqE0aMtedcYEll0XYci0qoK7S3s8ewvYm8DeQldrPb/fsI1COrlpdhYGRwvYmyFrjJaFmXCu9pGl/Wy9va2averHLB5foJUcWnNg0ie1D529RQt4Tn0ENR/B2Bl915NgaRHomKxhPwBuuwQ6Qoghy8nJIScn9EfL7/fT0dFBbm5u7MNOhRiihn6CiFybiaYuV9JbTDdEyTrp8jMtVBRqQxH3nGqPOigymmgbuudOyKOmbfB7f3SxduOqCGsxHa66xc7bhxsBuOncnoM4LzqzmPF5tmDL6f4yFROLQoHOnBgDHUVRmFOWx/tHm9l9sr1HoPO3HSdxe/3MGpfLPH2/j7MDTu1gte1dLje/yby9x/D/xIKh/NxQmdH4+cGxHRG5uuDQa7DnBTiyQcsUoCUbbP4O2PIr7WP8AvZlrSDTP4UzKsqYOS63x2sQfB39Pi1bsv8VrtvxIl+2noIm4OXgs4SCSVByFhTPhOJZ2v8Lp4JigPZqaNgH9XuhYR/3ndzFI9bjmLf7YLt2hGXAMgtwFPhvBXLHQ/5EyK+Agoko2eOZVfMapl/fC63Hw15gI0w6D868Cs78FOSV9XgpbF0uNr/6BtjBY8oiPIRvdimcUMfhy54CCy7u9+v4x9cP8vg/j3Dz1Ap+eO2ciLfZ9Oed7FBrWF5UBgYDNy+u4LmtVehbRaN+bymBoMSaoz3fgEy/ys9efxWvX+XiKy7uk13rTR8UOre/vWOZhXDGcu3jNEmLQMdqNuFQLWQobvAM3IdcCBGb/uZFiNQhX8fUFa10DUZO5zU9GOs9LDTcnLI8qlrsfHwy/kAnVLrWq3X1EPf+6EJtn/t/k1Q/kaztcOLy+oKZG/1k8/xpY5g0pucxjAaFG8+t4NE3DvU4Rn/Hh9D8oVjMmaAFOh/XtPO5wHWqqvL8lmOcpZzg3vF2lL8/BzXbofEgoFIGlOmJp260DMaBV7TLBpOWuZhwLkxYBOXnQnYJHF4Pe/4Gh9Zr1TO6MTNg9vV4pn+K7W/8lUXmQxgOvw6ndrCMHWy1mmkwXwpH3TD5QiYWZWLBQ1bVP+HlX8LBddCtBYqFgFM101y8hLJsRQtguhu14KP1eGiNEMyG4O7ZWrsQQIEuMskunwuFU/jo4BGy7DVMMTVrHXo7arSPqvcB7WR5mn4Akw2mXgxnXgkzrtBO3qMoyLRgNip4fCqNnS7G54eChWjft5HE0mJab9KgN0CYXZbHvAl57AoEIOUF8ZXlGQwKxTlWTrU7qe9wDRzoBH7O9H1hI0V6BDomAw4sZCCBjhCJYDYHOjrZ7WRkxFnTLEYcu137vah/XUXq6C9bEhwa6kpuRic4Qycn+lT5ORPyWLu7NmLb34G0dGsneIVZPb9/h7r3RxccFlrU/++6oiwLWRYj3W4fK3/2TnA/jL7/Y9Wiioj3u/Hccn7+5mF8frXf9r/656wGlckDtQlWVa3MqKOG5cpuuo3bqNjZysZ9bYxRmxnja+QVfxNWqxd6byfMr4Cyc9jmncKDH2czId/Gzz7pQTm5VduE3lUX2HPxEWz9DQA+DBgJ7b+pMYzj47yLufiGf8U6fraWNfB4qM+bj2/lf2FwtXF441P4tj/DmYZqKmrWwTPrIK+cT2edyU3Wd8mpcUBN4IC2PJh+Ofcemsyf26bzuxUXUqYHxF2NWsCjf9Tvg4b94OnWsklGixZsFc+EklnYC2aw/JlGTlHE9hsvpSjbyn/8+E2q3Q7+8oVPcO5Yv7bhvq0SWiuhrQp/ayU1rU7GXXw7pumXaV3TYqAFCzZq2hzUdzh7BDrBTGQMpZoV/ez/0kV602PV4gp2ndTK6wazr6k41xYIdPpvMe3x+UPZxjiC8NMhLQIdi8mAHRuFdEmgI0QCGI1G8vPzaWjQ+uRnZmYmpDOP3+/H7XbjdDpTrvwrFdeuqip2u52Ghgby8/MxGqNvtBYjj6qqYXt0+r4rrHc460r2Hp0ow0LDzR1CUNISaAvcJ6MzxL0/Or3TV8UAGR1FUTi7Ip/3jjRztLFn57UJBRksn1XS905dDZQeeJGNeU9Taj+Msr0ETkwKdN+aAPnlgf9XcHapVto1LdePwdEMzfVahy89+9BxCtrD/u/TvjfOBc7Vn3p4zKuA05iNbeK5MOEcKDsHyhZCtrZBf7rTw0cfr2dHK3xv7iUUn/cfWgDVXg3VWjthqrfiO7ULIz5OqmN4xfcJXvF9gj3qZLArPFxXwPVlEf42ZI/lx+2XsMF9Fv85z8lXct6H3X+F9mpK26tBgUbyGXvOdTDzKph0Pj7FxHPffw03/p5lhNljIftCmHJh6Dq/X9vr4nVpe2aMoa99JmAbuwkatYYE550xhlNtgdLBoizItmnHnHBO8D4+j4cd69ax8syVEOcbQsW51kCg07Pzb3N3/BmdmlZH1HbxkX4XXDVvPI9sOES3wxlxEO1ASgaYA6Q7VN+J2+snx2Ya1OMMp7QJdJyqRSsQdUugI0QilJaWAgSDnURQVRWHw0FGRsawtzRNtFRee35+fvDrKVJHp8uLw+MDImdL9NK1jmSXrvXTMEGnt/2tbunZ9jcWekanqNd9hrr3B7Rp86fa9UBn4BO4//38OeyqbqN3NejMcTmhjmeONq3Eavdf4PjboPqZBNo5StdJ7SOCs4Cjefng6sb4WIxZuqxiyCvDbiuhzTQWV+Y43JnjcGWW4s8Zz6xZs8Ec+VQw12ZmfJ7W0KGq2a59jymKlvHJr4A5NwBww8/eoLmuihsvPZ955QXMBtbvq+OPmytZs7WK6xdO6HPsunZnYHiqwkUXr4CSG2DFD+HAWlwNR7jpDSsfqWfw8fLLg5nJ+jYHbp8fk0HpkRmJyGDQ9u1EMbcsj2ON3ew+2c7kMVn4/CpWkyFqw4yh0EvJ9FbwupZA6VpR9sDf66W5NixGA26fn9p2Z5/9Yk6Pj3aH9j1RHPZzlmkx8fd/W8Ibb7zRb8fAaIrD5wD1Qx/2O6csr8/so2RLi0DHajJgJ/DN65GhoUIkgqIojBs3juLiYjyexJTGeDwe3n77bS644IKUK6NK1bWbzWbJ5KQoPYDIsZkinsQES9dGSEanv0AnL8PMpKJMTjTbe7T9jYV+whgpOBrK3h/Q3kFXVW0G0JgYTkizrabIj+NxwN4XtazF4fXBDfqAlkmZc4O278PRqnXcagt03mqvhrZq7V93F0ZXW+h+gSCGXP1jvJb9yR2vfeSMD3YPywx8xKu8MBDotNg5Z1LfvSiqqnKkxUenWsKlZ5UyvURr0DK9JJs1W6rYXtnKgboOzizt2Tzh+Q+r8flVFk0qZFrgPpgzYM4NWIET729A7XZT1WIPNlDQSwAnFGTE1Fq7P7PL8nhp5yl217QzLzDctaIwMZUJvUUbvNkSKF3rb1iozmBQmFCYwbHGbqpa7H0CHf13gc1sINfW89S+KMtCziD/JAUzOp39Z3T0AawjrWwN0iTQsRgNdAQDnb6DvIQQg2c0GhN2omw0GvF6vdhstpQKFiC11y5S00DdzELNCJK3R6fL5aXbrWed+n+3fM6E/MEFOhEGhoaOOfi9PwCVYUM84zoJ9vuh8YC2mf3Ee1pwE74pfuyZWnAz+3qttGogqgrOdjwtlWx670OWffomzLbh7yA7sTCLD461RN0bEj5MtTxs/k9xro1LZ5Xw6p461myp4v6rZwc/5/X5+VNgeOrNn4i8b6miMJOWbjdVzaFARx/qWVE09Oc9N2ygbKztwwdLz7A09MqK6G3RI33fRlJRmBkMdM7r9bn6ztA+uEQGa/raB8rohBoRSKCTFFazAYcqGR0hhBCjh35yE62bmR7odLmSl9HRg7Fsq2nAifNzynL5x65TwTa1sbC7vTg92ib43u2lYWh7fyB0cj1Qa2m8bqjdCZXvQ9UHULVZG8oYLq8C5lwPs2/Q2h/Hc0KqKJCRD8VZ2K0ntA32p0G0ltm6/oap3rx4Iq/uqePFHTV894ozMQee7luHm6htd1KQaeby2ZFLZisKM9lZ3dYjwKoKBp1Db4Bz1vhcFAVq253sqGwFYvgaD5Ie4OvzpHSR5j/1R9/7UhnhaxHKmia29K4kGOhEz+i4vX4O1HYCMLcsP6GPnwjpEeiYjDjQvpFUdzcjq3pQCCGEiF9w83GUbmYjob20vsb+GhHo5gROkuIJSvQWvRaTgcwI5Xs99v60NFNw7O8Y969lYUsXhncPQOksGDsTCieDoe/9Q62lAyfBejezluPalPemg1pgc3Jbz5bKAOZMrQVzxRKtLK18UXzBzQgwUFvjqrCMV29LpxYxsUgb/vmPXae47uxxAPzpQ20P0g0Lew5PDadnVyrDHlf//0BtvmORZTVxxthsDjd0sWFffdTnkAglwYxOr9K17ugll5HogVh1hK9FQ/DnLHp56GCESteiZ3QO1Xfi9vnJyzBTnoAgNNHSJNAJ7dHxu+1INboQQohUF+pmFi3Q0ffoJK90Ta/tjxaMhTurTNvHUdPmoLnLRVH2wMFRa1jZWqSSnTybiavyj3Nh9+vk/vJL4HNgACYAvPVB6IZGK4yZppWUFZ+p/WvOZNKJt7jbdITLqxzw60YtuHF3Rl5MRqEW1ExcAhVLYdzcHt2+UpF+8l85UKAToezLYFBYtaiCh149wJotVVx39jhaXFpGB+CmKO22IfJJfayDW2M1pyyPww1dwdK74Spdi5YVibd0bWKgZE9vdx6uPo6fs3jox2vpdveYDRUufH/OSGzEkxaBjsVowBkoXfM6uyXQEUIIkfKC7+JG2fsyMjI6sZfU5NrMTBmTxbEmre3vshnFA96nOVr5T1cD7FwDHz3DL5xHwAj4gLFn4pvzWQ4cOMDMIjA0HYTGQ1o2pn6P9hHmX0A7U+rdXDK3TOvqVThZayYwcSmMmZ5yGZuB6Cf/jZ0uHG5fn/I0PeMVLRtyw8IJPLz+ELtOtrP3VAeb6w2oqpbtmTI2+iyaiREySVXN3f0+VrzmTMjjhY9qgpeHL6Ojfe+32j3BYMHp8WEP7F0rjKHJRfj6IpURNvTTZn4o8jPNwW5vjZ0uJhT0fY1G8v4cSJdAJzyj45JmBEIIIVJfMFsSJaOjz9EZCaVrUTuuNezXOpGZbZBZxM15nbze7KHmkAkmLISMgoglZbqWThcWPJRleLTg5tRHsOOPcOg18GvP22PM4G+uxVROvIHvfPlf8Hu9HGldx/SVKzGYzVrjgLZKrXlA4wFoOACN+1G9bv7ZkMkJ31g+fdF5jCmfAQWTtdbK5sS+cz5S5WWYybGZ6HR6qWqxM6M0p8fn9exCtGxIUbaVy2eX8vKuUzyzpYoPGrRA8ObFE/t9XD1DpM+NsXt8tAbmJfU3VDUec3udmEc6iU+EvAwzFpMBt9dPQ4eL8kCjBQCzUSFngL1rOj3Q6XB6abO7yQ/r1hbLrKrBUBSFsTnaHKCGqIFOGxDaDzfSxBXoPPTQQ7zwwgscOHCAjIwMli5dyo9+9CNmzJjR7/3+8pe/8P3vf58TJ04wbdo0fvSjH7Fy5cohLTweRoOCK7BHx++WQEcIIUTq629YKIyM0rV+y+t2PgevfAO8oZKeLwFfsgLbAx8ENuFnFoFi0G7rdQX/vd7r5HobUAP8tNfxJyyCBZ9nR+aFfPfpPZQ1Z/CdSBkXg0HLzBROhhlXBK9u6nTxxR++gaLAv1x4BZhSYxBwIimKwsSiTPbUdEQMdELDVKMHCasWV/DyrlP8bccpQKEoy8KlkYanhinJsQWDg9p2Z3BGTFGWJRjAD9WscXkYFPCr2pwam3l46n0URaE4x8rJVi1YCA90CjIjl1xGkmExMjbHSmOni6oWe8RAJ9Gla6D9fqlpc0QcGury+jhYp5Vyzh4Ngc5bb73FHXfcwbnnnovX6+U///M/ueyyy9i3bx9ZWZE3h73//vvcdNNNPPTQQ1x55ZWsWbOGa665hh07djB79uyI9xkOzrA9OkIIIUQqU1V1wPk0uWFd11RVHXT9fLvDQ1NXz83IXo+Xegcca+zGFBg4WZBp6VNCpm9i7lFe53XBa9+FbU9plyedDwUTwd5CZ0s9jfU1FBm6yKMLULXZMo7WGFaqQHYxzPkMzP+8ttcGmOX0AHuCe39yrbEFLFWBbMX4vAwsaRjk6CoKQ4FOOLfXHzZMNXqDgMWTC5k6NoujjdrrecOCsgFfT4NBobwgg6ON3VQ224PBeqKyOaAFDtOKczhY35nQ40ZSkmvTAp3Az2zUkssBTCzMDAY6eotsGL5mBBC+x6hvQ4KDdZ14fCoFmWYmFIy8RgQQZ6Dz2muv9bj89NNPU1xczPbt27ngggsi3udnP/sZl19+Of/v//0/AB544AE2bNjA448/zhNPPDHIZcfPrehd16S9tBBCiNTW4fDi8mptlcdG3aOjZXT8KnS7fYN6J/xkq50Vj74dnIXTk4kHd74XvGQ0KLz4b0t7nYD1CsbaquHPt8CpHYACy+6GC/6fllUBFJeXS37wOqoKRnzk00Wh0kkhnSyYmM93rjwbTFYw2cBk5f7XjvPnnQ386yVnccfymRH3yOT02vtz3pSCmJ57aPP7yDyBO130IEbfI6M72WpHVSHD3P8wVUVRWLV4Ig+8sg8Flc+eUxbj42ZyNDA3pkMPdBK8j2bOhDwt0Bmm/Tm63kNDWwcZ6FQUZrKtsrVHi2m72xtsqJDoPTraMaO3mA42IpiQPyIbEcAQ9+i0t2tPsLCw77Rc3ebNm1m9enWP61asWMFLL70U9T4ulwuXKxQ5dnR0ANrk8cFMYPd4PLgV7QuluroSNsX9dNDXmkpr1snak0PWnhypvPb+jLbnM1roXZbyM81RS25sZgNGg4LPr9Ll9A4q0FmzpYputw+LyUBGj8dR8bg9mC1mQMHl9eH0+Pn9eyd49MaztVuoas/yuiMb4W9fBkeLtvfmuidh2vIej5dtNXHz4gr+sasWMOPFRr1axGGnlx3VCt8ond+j81O1u4EuMsnPzeq3EcCcCXlaoHMy9kCnsjlx7YxTWbQW01VxDFP9zDkTeG1PLTmu5piDCq3LWCOVLd3BfWYTExyQ3LBwAh9VtXL12eMTetzeigMlZfosncFmdPTMU3g3Oj2bk2kxJqysL1xxMEjrm9HZHey4lpvwx02UQb8ifr+fb3zjG5x33nn9lqDV1dVRUtKzFrOkpIS6urqo93nooYe47777+ly/fv16MjMH903uMWjfTO3NdWxat25Qx0imDRs2JHsJgyZrTw5Ze3Kk8tojsdul3HckCu59iZLNAe2d9BybiTa7h06nh9K8+Mpa3F4/f95WDcDPP3c2l88eF/ycx+Nh3bp1rFy5ArPZzM7qNq755Xus3V3LPVfOoiDLQqfLi8PjQ8HP+F2Pw9sPASqMOxs++0etXC2C/75mDv99zZzgZVVVmf/ABtrsHg7WdfbIGMXaondOWR5/33kqrhk9/bVOTieRZtpAfK9Prs3Mmi+dy7o4zr/CW0zrgU6ih3p+YkoRG7+1LKHHjKR3VqSlWwsaYm0trauIMDQ0vIR1OLIqepCmNz8J97HecW0EDgrVDTrQueOOO9izZw/vvvtuItcDwN13390jC9TR0UF5eTmXXXYZubnxR40ej4d3P9oJaO9+nc5GCEPl8XjYsGEDl156KWZzavXjl7Unh6w9OVJ57f3RM+piZGkYqJtZgB7odAyi89qGffU0dbkZm2Plkplhb1g6WjF8+BQTm6pRjmfD2KnMG1/GWeNz2Xuqg7/tOMmXz59CQ4eTXLr4he0JzG/v0O674Fa44sdxdS1TFIU5ZXm8c7iJ3TXtEQOdgsz+Txj1+8QT6FT3MwwznejP/2SLA79fxWDQTqYHai09VBPDTuqDGZ2i1MyuBQdvBn5uW7q1THmsw0J1etAZnl3Ts0TRSliHqvfadU6Pj8P1WiOC3h3sRpJBBTp33nknr7zyCm+//TYTJkzo97alpaXU19f3uK6+vp7S0tKo97FarVitfb9gZrN50CcQHoMV/GDwOlPyJGQozz3ZZO3JIWtPjlReeySj6bmMJnrpWvEAXZZyrGbAMajOa2u2VgLwuXPLMRsDm8e9bnhuFcaq9zkbYM3vAVAMJv5kG8dH5nza3i5DVZbit2fwD8tPmEiDtqfmUw/D/H+Jex1AKNA52Q6LQ9cHMzoDzCI5a3wuigK17c4+jRWiqRzmE/lUMS7Phsmg4Pb5qetwMj5f27OkZ3iGa9CmnimqbLbj8Gh7xFL1axEsXRtiRkfPaNW2O3B7/VhMhr774BIsmI3qldHZX9uB169SlGVhXJzZ4tMprjYiqqpy55138uKLL/Lmm28yefLkAe+zZMkSNm7c2OO6DRs2sGTJkvhWOkTeQDMCg1fKMIQQQqS2WAcEZod1XovH8aZu3jvSjKLAjeeWa1eqKqxdDVXvo1pzqMudh1o0DYxW8HvJsVdzgXE3n/a8hvLGPUx///8x0dBAg7EUvrR+0EEOhN4x1jc/A3h8/mDb4cKs/l+HLKuJqYEBlXtODZyldLh9wY5xw3UinypMRgNlgY5a4ZmE6mCzhuF5fcoDM1u6XF58fhWLydBvqeZIFsyKdOoZHX2PTnzPZ2y2lQyzEb8KNW1ac61Qa+lhyugEgrQ2uwenJ9SUZE/YoNCR2ogA4szo3HHHHaxZs4a///3v5OTkBPfZ5OXlkZGh/RDccsstlJWV8dBDDwHw9a9/nQsvvJCHH36YT33qU/zpT39i27Zt/OY3v0nwU+mfJxjoSNc1IYQQqW2g1tI6vcV0vENDn9taBcCy6WNDQwI/+DV89AwoBnzX/JYth9ysXLkSs9EInbXQepy/bnyX2uP7WVLQQbnSwFstReya/v/44bh5cT7DnuYESs8O1Xfi9PiwmY202rWTRUXRhjIOZG5ZHkcauthd08HUAW5b3aqdxOfYTDEde7SrKMykstlOVYudT0wpQlXVYNCT6AYBugyLkeIcazA4qCjMDJbNpRq97XO7QwsWgiWXWfF9bymKQkVhJgfrO6lqsTN5TNbAQ3mHKDfDhNVkwOX10xiYAwRhHddG6PwcXVwZnV//+te0t7ezbNkyxo0bF/x4/vnng7epqqqitrY2eHnp0qWsWbOG3/zmN8ybN4+//vWvvPTSS6d1hg6Az6BFukafBDpCCCFSWyjQ6f9d3MEMDXV6fPwl0IQgOMH+8Buw/r+0/1/236hnhHVLMxggrwwmfZIzL/9XHvZ+lptabueH4x7n296vklMwNubHjmZ8no3CLAtev8qBwIDCVn2fQ6YFYwwnwPpAw70xZHTC95+M5HerT5dg57XA69LU5cbu9qEoBLM9w/m4vf+fanJtJmxm7ZS7ocMV1kQj/ixMefBrobX7Dg3lHZ6MjqIoEVtM765JjUAnroyOqqoD3mbTpk19rvvMZz7DZz7zmXgeKuG8wUDHqaXf5ReXEEKIFKW/izt2oD06g8jovL63jla7h3F5NpbNGAuNB+GvXwDVr5WffeLfwBv5eLPL8phXns+u6jbW7tbe9EzEbA+9IcFbhxrZfbKNs8vzaQ7sc4i1Ra9e/ranpoNPD9Bherj3n6Sa3pvg9X/H52X0aPedaBVF2twYSO1ARw8WKpvtnGp30BYsuYxvjw70/Vo0dg5vRge07o5VLfbg7x2H28fhhi6AHs1BRqK0GfXrMwZK11Qf+NxJXo0QQggxOKqqhp3cDJTRiT/QeXaLVrZ247nlmFxtsOZGcHVAxVL41KMDvlF486IKAHx+NbDGxJyA6YGK/k5ycJ/DAB3XdLPG52JQtC5V7QOcBgz3/pNUE2xrHAx0tGzCcA9THS0ZHQi1gj9Y14meN8jPjL8ssneL6VhazQ+V/jOst5jeV9uBz68yJts6LENKEyl9Ah0l7AvhkYYEQgghUlOb3YPb5wcGbimbbdVL12ILdA7Xd7L1eAtGg8LnFoyDv9wKrcchrwJufAZMAwcVV84bR07Y4MJEnQjppWf63oB4p8tnWkycUaw1JKju7j9YqwyUBaX7sFBd+EwbgKpmbRvAcL8+4Rm1VM+u6ft0DtRppZN5GeZQN8M4VIRldLpcXrrdvh7HHw69h4buPtkGaG8+jPTSzrQJdBSjCY8aSK+6JdARQgiRmvQ2r4VZlgHLhkIZndj26KwJNCG4+MxiSt+/F46/DZZsWPUnyBoT0zEyLSauW1AWvDxQC+xY6Rmdww1dOD2+0HT5AVpLh9MHG1Z39X9yViUzdHrQX4eWbjedTg+VgYzOcA9THU0ZHb172f5abY9ZvK2ldRVhQWddu/a7INtqIts66NGYAwpmdALZo901WrA20vfnQBoFOmYDOAi8q+SRhgRCCCFSk/6uaiylKvGWrr26W+umelfB27Dtd4AC1/0WSs6Ka42rAk0MLCZDwgYZlubaGJNtxedX2VfbEXfpGsCcMm3o+Mnu6Lfx+1WqW7XzhFQ/uU6UHJs5mDmrarGftmGqk4qyUBQwG5WULyPUM5sHA8004h0WqptQkIGiQLfbx/5aLeAYrkYEOn3t+pssu2vaAAl0RhSTAg4C31Sefn7DCSGESEm//OUvmTRpEjabjcWLF7N169Z+b//YY48xY8YMMjIyKC8v55vf/CZOp7Pf+4wEsbaWBsjVu665Bs7oeHx+6judnGfYzfQd/61dufxeOHNl3GucUZrDL26azy9umo/NnJjN6lpDAi1Q2X2yPWwWSewnjFMCs3SanNEzOvWdTtxeP0aDwvj8kTsI8XQL77x2uoapFmVb+ckN83j0xrMT9n2ULPrPqz78dDCNCACsJiPjAsfadqJFO3aCsqbRlAQHnrqwu70cCTQimDNBAp0Rw2RQsauS0RFCiNHo+eefZ/Xq1dx7773s2LGDefPmsWLFChoaGiLefs2aNXz3u9/l3nvvZf/+/fzud7/j+eef5z//8z9P88rj1xDH5uPgwNAYMjpNXS4mUsuvzD9HUX0w93Nw3jcGvc6r5o1nxVmlg75/JPo8nY/DAp2iOErX9BPzZlf0TrJ6C+Wy/AxMg9hDMVrpr93B+s4es22G2w0LJ3Dl3PHD/jjDrXfWZbClaxAqGfzwhNaRbrgbAuhrb+hwsu9UB35Ve8zh7PSWKGnzE2w2gFMvXXNLRkcIIUaTRx55hNtvv50vfOELzJo1iyeeeILMzEyeeuqpiLd///33Oe+881i1ahWTJk3isssu46abbhowCzQSNMTRTjbm0jVHG7z1Y1603Eue0g0TzoWrfjbiRjHMLdNbRIcCnYI4StfKCjIwKODxKzR2RW69Jq2lI9Nfj/ePNgPa99Zguoalq9571QZbugahAHN/nV66NrwBh378DqeXLce1LFIqlK1BnHN0UpnJAHbZoyOEEKOO2+1m+/bt3H333cHrDAYDy5cvZ/PmzRHvs3TpUv7v//6PrVu3smjRIo4dO8a6dev4/Oc/H/H2LpcLl8sVvNzRoZ1geDwePJ7Yh3Hq9PsM5r61bdrfsDFZpgHvnxGo9ulwRllndxOGrU9g2PYk49xdoMAJ40TKrn8aMEKU4w9l/UNxZol2gne4oTO4+TrXaohrHePybNS0OTnW0BExK3aiUSvLKcu3nfbnN5Bkve4A4/O012pHYK5NeUEG3ijzlCJJ5tqHKhFrL8zoWXqXbzMO+nhleVrgoSclx2SZox4rEWu3GVQyzAYcHj9v7NP28c0al5PUr2Wsj50+gY4CDlXfoyOBjhBCjBZNTU34fD5KSkp6XF9SUsKBAwci3mfVqlU0NTXxyU9+ElVV8Xq9fO1rX4tauvbQQw9x33339bl+/fr1ZGYO/p3/DRs2xH2fQ9VGQKH68F7WNe/p97YOL4AJj0/l76+sIzCcHZunlan165jU/E+Mfi2zUWuawA/t11Kdey5ffHv7sK1/qHLNRjo8Ch2BLNWuLe9SGUflTpZqAAy89u42Wg72LV/74JD2eXt9JevWnUjImhMtGa/7qQ4AE97AfCSLq51169bFfZxkrD1RhrJ2VQWLwYjbr2VJq4/sZ137vkEdq6VJAUKBU82Rfaxr29vvfYb6umcZjTg8Cjur2wAF56lDrFt3cEjHHAq7PbYOymkT6Ghd1wKpPWlGIIQQaW3Tpk08+OCD/OpXv2Lx4sUcOXKEr3/96zzwwAN8//vf73P7u+++m9WrVwcvd3R0UF5ezmWXXUZubm7cj+/xeNiwYQOXXnopZnN85T//s+9twMkVy5Yyb4DNwD6/ync/1E5wPrnsEoq89Rg2/xzD/jUogeHZ/nFn4z9vNc9UncErb59g1fQJrFw5a9jWP1R/b/mINw82Bi9ff+UKrHFsVH/XtZtDO2rJHT+VlZdO7/P5p6q3AO1cunQBl59V0vcASZTM17223ckv9r4dvHzurCmsXNH39YsmmWsfqkSt/bHD73IisAds2ZJzuHD62EEdp+xkO384vCV4ecUFn+DcSQURb5uotf9f7Yc0nWhFRQvUbvv0xQnrqDgYelZ9IGkW6EhGRwghRpsxY8ZgNBqpr6/vcX19fT2lpZE3w3//+9/n85//PF/+8pcBmDNnDt3d3XzlK1/hv/7rvzAYem5htVqtWK19/6ibzeYhnTzEe3+/X6UxsEenrDBrwPua0WZsuFxOMt/4Dub9fwJ/oNyoYglccBeGqZdgUBSaDuwCYFxeZsxrGurzH4x55QXBQCfLYiQ7M779CROLtM5rp9pdEdeut5aeUpwzYk/Ik/G6Tyg0YTEZcHu1YbWTxw7u9UnG2hNlqGsvybUFA53iOH7Oepta3PPNlZh+Fwxx7aV5GYBWtjguz8b4wuxBHysRYn0uadOMwKgQ6romzQiEEGLUsFgsLFy4kI0bNwav8/v9bNy4kSVLlkS8j91u7xPMGI1aViBaN66RoNXuxutXURQYkx3bu6k5NhOfM75J7t7/04KcKRfBbevgi6/BGcuDDQf0+TwjvZPSnAmhk7x4hoXqKgozgFBAE67T6Qk2OZAZOj0ZDArlBRnBy/L6xC/8Z2uw7aUB8jPN5IQNCE3UUN7+lIRlb2anSCMCSLuMjjQjEEKI0Wj16tXceuutnHPOOSxatIjHHnuM7u5uvvCFLwBwyy23UFZWxkMPPQTAVVddxSOPPML8+fODpWvf//73ueqqq4IBz0ikByNFWRbMMbY+zrGZuMERKDla/gP45Dcj3k7v5jbcwweHKvwkK55hobrygsA8mJa+Nf7VLdr5QWGWhRxbamYdhtPEoiyONnYH/i+BTrzCm18MJdBRFIWKokz2nuogx2YiwzL8v7PCfy/MlUBn5NHaS+ula7FtYBJCCJEabrzxRhobG7nnnnuoq6vj7LPP5rXXXgs2KKiqquqRwfne976Hoih873vfo6amhrFjx3LVVVfxwx/+MFlPISb6ZPJ43sGdaaxhnuEYfsWEYX7krnIQms8z0jM6xTk2xuXZqG13DupkUc/oNHW5sbu9ZFpCp0JVLdpJfLlkKyLSszgmg8K4vJH9fTIS6T9bNrOhx/fdYFQUaoHO6fp5DX+cVBgUqkubQKfnwFAJdIQQYrS58847ufPOOyN+btOmTT0um0wm7r33Xu69997TsLLECQUjsWddLvP8E4Da4vMpyxoT8TZur5/mQMnWSA90QMvqaIFO/Nmn3AwzmUYVu0+hqsXOmaWhUjg9yzNRAp2I9ECnrECGqQ6GnhUpGsT3bW/60NDhHhaqC39zJVVm6EAa7dExKWGla24JdIQQQqSe403a36/x+RkD3DLA5+WTdm3v0oGSq6LerLFLK1szGxUKUmAI5PnTtIBtRungNkQXBc7Zqpp7ng9UBi7L/pPIzq7I1/4tz0/qOlLVWeO1oHpGac6QjzU/8DWYNS7+ro+DcUZxNhajgZnjcimKcX/gSJA2GZ2ee3Qk0BFCCJF6dte0AXFsBj62iTxfMy1qNvuyl3BJlJvVd4RK4pRAc4KR7F8WT2Tx5CKmFQ8u0BljU6nuVvrs09EvS6AT2YKKAt5YfSETCmIMtEUPZxTn8M+7liUkC7PirFLWf/MCJo/JSsDKBjY2x8rGb11IbortXUubQMdkCB8YKoGOEEKI1KKqKrtPtgNxlI7sWgPAy76ldPQzSLyhIzUaEegMBmVI74oHMzrRAh3ZaB/VGYMMLoUmUYGJoihMLxl6Zigeqbh3La1K1+zBgaHSdU0IIURqqWqx0+H0YjEaYjvBcbTB/lcA+JvvAjqd3qg3bQg0OSg5DW1qR4IxVq2FeGVY6ZrX56cm0HJaMjpCjA5pE+iEd11TZY6OEEKIFPNxIJszc1wOFlMMf773vgg+F61ZU9mtTu430KkfRJODVKZndKrDMjq17U68fhWL0UBpCjRkEEIMLG0CHZMhNDBUlWYEQgghUsyeGi3QiXl/zq7nADhZcQ2g0OGMXrtWHyxdS48T/DE2LaNT3WrH59f+r5etTSjMwGAY+fuUhBADS6tAR5oRCCGESFV6RmduLDMsmo9C9RZQDDRNvQYgxoxOegQ6+Ratw5zHp1IXeO7SWlqI0SdtAh2jAi5F9ugIIYRIPX6/GszozCnLH/gOO7UmBEy9GGvBeAC6XP3s0dEzOjnpUbpmUKAs0KK7srk78K90XBNitEmbQAfAb9ICHUUyOkIIIVJIZYudTpcXq8nAtJIBul75/fDx89r/z14VbAfb2U/pWrAZQZpkdADKAy2S9X061cGOa6enXa8QYvilVaDjM2q/1BSfC/y+JK9GCCGEiM3HJ9sAmDkuF/NAE+lPvAPt1WDNgxmfIsemTZKIVrrm8vpotWtBULo0I4BQ5kYvWats6e5xvRAi9aVloANI+ZoQQoiUsTue/Tl62drsa8FsIyeQ0bG7fXh9/j4318vWLCYDeRmpNQxwKMoL9dI1LdCpCvw7UWboCDFqpFWgo5rCUvJSviaEECJF7K6JcVCoqxP2v6z9/+ybAci2hmaDd7v6VjOEytasKEr6dBsLL11rs7vpCGS8ygsk0BFitEirQMdqNgZbTEugI4QQIhX0aEQwUEZn38va37fCqTDhXEDL1FgDc3citZjWW0uny7BQnV6iVtliD5avFedYybAYk7ksIUQCpVmgY8Cut5iWWTpCCCFSwLGmbrrdPmxmA2eMHaARQWB2DmffBGHZmZxgQ4K++3T01tLFabQ/B2BCIKPTZvewp6YDkP05Qow2aRXoWIwGnFi0C7JHRwghRArQszlnjc/D1F8jgtYTWiMCFJj7uR6fyg02JOib0Wno1FtLp1dGJ9tqYky2dk7w3pEmQAIdIUabtAp0rCYDjmDpWndyFyOEEELEQB8UOuD+nF2BltKTL4D88h6fyg4EOpFm6aTbsNBw5YHA5r2jgUBHGhEIMaqkWaBjDJWuSUZHCCFECthd0wYMEOioaljZ2qo+n+6vxbTedS2dWkvrJgYCnbZAe23J6AgxuqRVoGMxhZWuuSWjI4QQYmTz+dXg/pF+W0tXfQCtx8GSDTOv6vPpHGv0oaHpnNHpHdhIa2khRpe0C3RCXdckoyOEEGJkO9bYhcPjI9NiZEp/jQh2Pqv9O+tqsGT1+bSe0enopxlBOmZ0ynsFOr0vCyFSW1oFOlaTAQfSXloIIURq0PfnnDU+F6Mhyowbtx32vqT9P0LZGkTfo+P0+ILBz9g0a0YAMLEoFBRmmI2MzU6/YE+I0SytAh2LBDpCCCFSSGhQaH70Gx1YC+5OyK+AiqURbxJqL92zdE3fn2MzG4Kd2dJJeOlaRWFmWg1MFSIdpFWgo3Vd0/foSKAjhBBiZNMDnX735+z4g/bvvJvAEPnPem6UZgT1naH9Oel4kl+cYw0OU5WOa0KMPmkX6NgJpOYloyOEEGIE8/r87D2lBTqzo3Vcq96qzc4xmGDBLVGPFa3rWnB/ThqWrQEYDEpwX450XBNi9Em7QMcRHBgqgY4QQoiRq6rFjtPjJ8NsZMqYvg0GAHjnEe3feZ+DvAlRj5WXof3tq2zuRlXV4PX1gdK14jRsRKCbOlZ7baeMjfIaCyFSVloV5FqMBrql65oQQogUoDcOKMg0Y4jUiKBuDxx6FVDgvG/2e6wlU4qwmgwcbexmR1UbCycWANCQxq2ldXddNoOZ43K55uyyZC9FCJFg6ZXRMRtDzQhkjo4QQogRzOH2AWCzGCPf4N1ANuesa2DMGf0eKy/TzFXzxgPw7JbK4PV66VpxTvpmdKaV5PCN5dPJsqbVe79CpIW0CnQsJgN2JKMjhBBi5LN7tEAnwxwh0Gk+Cntf1P5//rdiOt6qxRUArP24lna71n2toVMrXUvnjI4QYvRKr0DHaMCpyh4dIYQQI58zkNHJjJTRefdRUP0wbQWUzonpePPL8zmzNAeX18/fdpwEwjI6abxHRwgxeqVVoGPtkdGRQEcIIcTI5QhkdGy9MzrtJ2HXn7T/x5jNAVAUhZs/MRHQytdUVQ3O0ZGMjhBiNEq7QMchpWtCCCFSgN0dpXTt/cfB74FJ50PF4riOec3Z48m0GDna2M2mQ410BhoeSKAjhBiN0ivQMRtwqNKMQAghxMjn9EQoXetugu1Pa/8/f3Xcx8yxmfl0oCnBYxsOAZBlMZItG/GFEKNQWgU6FqNkdIQQQqQGvetaRnig88GvwOuA8fNhykWDOq7elGDXSW0YqWRzhBCjVVoFOrJHRwghRKqw996j42yHrb/V/n/+t0CJMFsnBnMn5DOnLC94eWwat5YWQoxuaRboGHGEd10Lmw4thBBCjCSO3l3XPnwSXB0w9kyY8akhHVvP6oBkdIQQo1daBToWk4JTz+iofvC6krsgIYQQIgpn+Bwdtx02/0r7xCdXg2Fof74/PW98cF9OibSWFkKMUmkV6FhNRhxYQldI+ZoQQogRKth1zWKCHX8EexPkT4TZ1w/52FlWEzd/QsvqzCvPH/LxhBBiJEqrNisWkwEvJtyqEYviCwQ6hclelhBCCNGHPkcny+iH93+uXfnJb4AxMX+6v7PiTD6zsJypY7MScjwhhBhp0iyjoz1d6bwmhBBipNNL16bXvwIdNZBdCvNWJez4BoPCGcXZKINsaiCEECNdWgU6lt6BjszSEUIIMULZ3T4M+Jlx5HfaFUvvBLM0DhBCiFilVaCjZ3TsqmR0hBBCjGwOt4+Vhi1kdVVCRgEs/EKylySEECklrQIdk0HBoBDqvOaRjI4QQoiRyen2cofp79qFxf8K1uzkLkgIIVJMWgU6iqJg6TE0VDI6QgghRqYi90lmGqrwG62w6PZkL0cIIVJOWgU60GtoqFvaSwshhBiZLJ4OAHwZYyBTOoQKIUS80jDQMYR1XZNARwghxMhk8AWqDiyZyV2IEEKkqPQLdMwGaS8thBBiRPP5VSw+7c04xSJ7c4QQYjDSLtCxGA1hXdekGYEQQoiRx+HxkYkLAMUqAz2FEGIw0i7QsZqMOAns0ZGMjhBCiBHI4faRoWiBjsEigY4QQgxG+gU65rCua9KMQAghxAjkcPvIwgmAInt0hBBiUNIu0LEYDThUaUYghBBi5HJ4fGQESteQjI4QQgxK2gU6VrNRuq4JIYQY0RweH5mB0jXMEugIIcRgpF+gY5Kua0IIIUY2u9sbbEYg7aWFEGJw0jPQCQ4Mla5rQgghRh6nx0dmYI+OlK4JIcTgpF2gYzGFNSOQjI4QQogRyOH2S+maEEIMUdyBzttvv81VV13F+PHjURSFl156qd/bb9q0CUVR+nzU1dUNds1DorWXljk6QgghRi672xvWjEBK14QQYjDiDnS6u7uZN28ev/zlL+O638GDB6mtrQ1+FBcXx/vQCWE1hQ8MlYyOEEKIkcfpCbWXloyOEEIMjineO1xxxRVcccUVcT9QcXEx+fn5cd8v0bRmBPoeHem6JoQQYuTp0XVN9ugIIcSgxB3oDNbZZ5+Ny+Vi9uzZ/OAHP+C8886LeluXy4XL5Qpe7ujoAMDj8eDxeOJ+bP0+Ho8Hk4Fg1zXVY8c7iOOdTuFrTzWy9uSQtSdHKq+9P6Pt+aQKu9snpWtCCDFEwx7ojBs3jieeeIJzzjkHl8vFk08+ybJly9iyZQsLFiyIeJ+HHnqI++67r8/169evJzNz8L/wN2zYwImTSnBgqN/Vxbp16wZ9vNNpw4YNyV7CoMnak0PWnhypvPZI7HbJfCeDw+MLtZeW0jUhhBiUYQ90ZsyYwYwZM4KXly5dytGjR3n00Ud55plnIt7n7rvvZvXq1cHLHR0dlJeXc9lll5Gbmxv3GjweDxs2bODSSy+lbmsN71VvB8Coell5+WVgOG2JrbiFr91sNid7OXGRtSeHrD05Unnt/dEz6uL0crp9ZCrSXloIIYYiKWf4ixYt4t133436eavVitVq7XO92Wwe0gmE2Wwmw2oODQwFzKoHzBmDPubpMtTnnkyy9uSQtSdHKq89ktH0XFKJ3e2TgaFCCDFESZmjs3PnTsaNG5eMh8ZqMuDCjB9Fu0I6rwkhhBhhnG43GYpbuyCla0IIMShxZ3S6uro4cuRI8PLx48fZuXMnhYWFVFRUcPfdd1NTU8Mf//hHAB577DEmT57MWWedhdPp5Mknn+TNN99k/fr1iXsWcbCajICCW7FiU53gkfpzIYQQI4s/vCuolK4JIcSgxB3obNu2jYsuuih4Wd9Lc+utt/L0009TW1tLVVVV8PNut5tvfetb1NTUkJmZydy5c3njjTd6HON0spi0JJZTsUmgI4QQYkTyu7SB1ioKSgqUVwshxEgUd6CzbNkyVFWN+vmnn366x+Vvf/vbfPvb3457YcPFGgh0XMjQUCGEECNUIKPjM2ZgUpQkL0YIIVJTUvboJJNWuhaapYO7O4mrEUIIkSi//OUvmTRpEjabjcWLF7N169Z+b9/W1sYdd9zBuHHjsFqtTJ8+feSMHPBof5v8ks0RQohBG7l9lYeJ1azFdg7J6AghxKjx/PPPs3r1ap544gkWL17MY489xooVKzh48CDFxcV9bu92u7n00kspLi7mr3/9K2VlZVRWVpKfn3/6Fx+BEiirVqURgRBCDFraBToWY+9ARzI6QgiR6h555BFuv/12vvCFLwDwxBNPsHbtWp566im++93v9rn9U089RUtLC++//36whfakSZNO55L7ZQgGOtJaWgghBivtAh09o2NXLdoVktERQoiU5na72b59O3fffXfwOoPBwPLly9m8eXPE+7z88sssWbKEO+64g7///e+MHTuWVatW8Z3vfAej0djn9i6XC5fLFbysD1L1eDx4PJ6416zfJ9p9jb5AoGPKGNTxh9tA6x/JZO3JIWtPjlRee39ifT7pF+gE9ujY/RZQCG74FEIIkZqamprw+XyUlJT0uL6kpIQDBw5EvM+xY8d48803ufnmm1m3bh1Hjhzh3/7t3/B4PNx77719bv/QQw9x33339bl+/fr1ZGYOPuuyYcOGiNcbPN1ghtZuNx+OlH1DEURbfyqQtSeHrD05UnntkdjtsZ2/p12go7eX7lIDgY60lxZCiLTj9/spLi7mN7/5DUajkYULF1JTU8NPfvKTiIHO3XffHRynAFpGp7y8nMsuu4zc3Ny4H9/j8bBhwwYuvfTSYOlc8HM+P1u2vgVAUekEVq5cGffxh1t/6x/pZO3JIWtPjlRee3/0rPpA0i7Q0dtLd/stWs85CXSEECKljRkzBqPRSH19fY/r6+vrKS0tjXifcePGYTabe5SpzZw5k7q6OtxuNxaLpcftrVYrVqu1z3HMZvOQTh4i3d/h85CBEwCTLQfjCD45GerzTyZZe3LI2pMjldceSazPJQ3bSwf26ASbEUigI4QQqcxisbBw4UI2btwYvM7v97Nx40aWLFkS8T7nnXceR44cwe/3B687dOgQ48aN6xPknG4Ot49MtP1ABqt0XRNCiMFKw0BHe/fOGZyjI4GOEEKkutWrV/Pb3/6WP/zhD+zfv59//dd/pbu7O9iF7ZZbbunRrOBf//VfaWlp4etf/zqHDh1i7dq1PPjgg9xxxx3JegpBDrePLEULdBRLdpJXI4QQqSvtStfMRm3CtF2VOTpCCDFa3HjjjTQ2NnLPPfdQV1fH2WefzWuvvRZsUFBVVYXBEHpvr7y8nNdff51vfvObzJ07l7KyMr7+9a/zne98J1lPIcjh8QVL17BIe2khhBistAt0FEXBajLgCLaXljk6QggxGtx5553ceeedET+3adOmPtctWbKEDz74YJhXFT97WOkaMkdHCCEGLe1K10DbpxMaGCoZHSGEECOH0+MjU9EzOlK6JoQQg5WWgY7FZMShyh4dIYQQI094MwIpXRNCiMFLy0DHajJI1zUhhBAjkt3jI1OR0jUhhBiq9Ax0zFK6JoQQYmRyun1kBpsRSHtpIYQYrPQMdMJL16QZgRBCiBHE4QkvXZNARwghBistAx2LyYADveuaZHSEEEKMHHa3jwwpXRNCiCFLy0Cnxx4daUYghBBiBJGMjhBCJEbaBjpONawZgaomd0FCCCFEgNMje3SEECIR0jbQCWZ0UMHrTOp6hBBCCJ3T5cSi+LQLUromhBCDlqaBjjHUdQ1kn44QQogRw+cMa5IjGR0hhBi0NA10DPgx4DUEGhK4pfOaEEKIEcKl/U3yK0YwWpK8GCGESF3pGeiYtaftNdi0KySjI4QQYoTwu7sA8BozQVGSvBohhEhdaRnoZFlMALgVmaUjhBBiZFEDVQY+U0aSVyKEEKktLQOdbJsW6LgkoyOEEGKEUQJ/k/wmaUQghBBDkZ6BjjUQ6MgsHSGEECOMIVBloJqlEYEQQgxFWgY6OYGMTrDzmkcCHSGEECODwRv4m2SRjI4QQgxFWgY62VYzAHZVAh0hhBAji8EbKKeWGTpCCDEk6RnoBDI63WqgbacEOkIIIUYIcyCjo1ildE0IIYYiPQOdwB6dbr8+R0cCHSGEEMmnqiomv5bRMVizk7waIYRIbWkZ6Oh7dDr1QEe6rgkhhBgB3D4/GbgAMEpGRwghhiQtA52sQEanw6vt1ZE5OkIIIUYCh9sXCnRsEugIIcRQpGWgo5eudamS0RFCCDFyODw+snACYLTmJHk1QgiR2tI60HFI1zUhhBAjiMPtI0PRMjrSdU0IIYYmLQMdo0Eh02IMzdGRZgRCCCFGALvbR2agdE3m6AghxNCkZaADWlbHgZSuCSGEGDmcHh+ZgdI1LNJ1TQghhiJ9Ax2bKWxgqDQjEEIIkXwOj49MKV0TQoiESNtAJ8dqwqmXrklGRwghxAggpWtCCJE4aRvoZNtM2GWPjhBCiBHE6fGRoZeumaW9tBBCDEX6BjpWE45ge2kJdIQQQiSfw+0jSy9ds0igI4QQQ5HGgY451HVNAh0hhBAjgD1sYKgEOkIIMTRpG+jk2EwS6AghhBhRHG5vqOuaNCMQQoghSdtARytdkz06QgghRg6vy45RUbULktERQoghSd9AJ7wZgd8DPk9yFySEECLteZxh4w4k0BFCiCFJ30DHasKpDwwFKV8TQgiRdH63Fuh4FQsYjElejRBCpLa0DXRybCZcmPHrL4HM0hFCCJFkflcg0DFmJHklQgiR+tI20Mm2mgAFl6Lv0+nu9/ZCCCHEsHN1AeA1SSMCIYQYqrQNdLKsJoCwzmuS0RFCCJFcaqCM2m+SjI4QQgxV2gY62XqgI0NDhRBCjBCKWw90JKMjhBBDlbaBTo5NC3S6VZmlI4QQYmQweLUyalU6rgkhxJClbaCjZ3TswYyOlK4JIYRILoM38KabDAsVQoghS99Ax6YHOtKMQAghxMhg9AbedJOMjhBCDFnaBjpWkxGL0SDNCIQQQowYJp/2t8hglUBHCCGGKm0DHdCyOqFAR/boCCGESC5zMNDJTvJKhBAi9aV3oGM1Sdc1IYQQI4Lfr2Lxa4GOUTI6QggxZGkf6Nj1jI5bAh0hhBDJ4/L6ycAFgMkmgY4QQgxVegc6UromhBBihHB4fGQpTgBMtpwkr0YIIVJfWgc6OVYTTqR0TQghRPLZ3d5gRkeaEQghxNCldaCTbTOF2ktL1zUhhBBJ5PT4yAwEOpgl0BFCiKFK70DHGla6JnN0hBBCJJHD7SdTCQQ6FhkYKoQQQ5XegU6PPTqS0RFCCJE8dreXTLQ9OjIwVAghhi6tA50cqwmHKs0IhBBCJJ9DSteEECKh0jrQ6dFeWgIdIYQQSeT0+MiQ0jUhhEiY9A50bOZQ1zWZoyOEECKJ7G4fWVK6JoQQCZPegY7VKF3XhBBCjAgOt4cMxa1dkNI1IYQYsjQPdMxhzQik65oQQojk8TjC/g5J6ZoQQgxZegc6tvA9OsOb0fH51WE9vhBCiNTmdXaFLpgykrcQIYQYJdI70LGacIZ3XVOHJxg50tDF2fet55ENh4bl+EIIIVKf36UFOm5DBhjS+s+zEEIkRNy/Sd9++22uuuoqxo8fj6IovPTSSwPeZ9OmTSxYsACr1coZZ5zB008/PYilJl5OeEYHhi2rs+1EC50uL28fahyW4wshhEh9PpdWuuYx2pK8EiGEGB3iDnS6u7uZN28ev/zlL2O6/fHjx/nUpz7FRRddxM6dO/nGN77Bl7/8ZV5//fW4F5to2VZTqOsaDFug09ytbS5td3iG5fhCCCFSnxoIdLxG2Z8jhBCJYIr3DldccQVXXHFFzLd/4oknmDx5Mg8//DAAM2fO5N133+XRRx9lxYoV8T58QmVajKiKAadqxqZ4Ag0JihL+OM1dEugIIYQYQKApjs8kgY4QQiRC3IFOvDZv3szy5ct7XLdixQq+8Y1vRL2Py+XC5XIFL3d0dADg8XjweOIPFvT7RLpvttWEQ7Viw4PH0QlZiQ9GGju1TFG7w4Pb7UZRlJjv29/aRzpZe3LI2pMjldfen9H2fEY0tx7oSCMCIYRIhGEPdOrq6igpKelxXUlJCR0dHTgcDjIy+v5Cf+ihh7jvvvv6XL9+/XoyMwf/TteGDRv6XGf0G7ErVgro4v1N62nLPDLo40dzsNIAGPD5VV78x6vYBvGqR1p7qpC1J4esPTlSee2R2O0yTPl0UTzaa61KRkcIIRJi2AOdwbj77rtZvXp18HJHRwfl5eVcdtll5Obmxn08j8fDhg0buPTSSzGbzT0+9/jR93C2WUCB8xYtQK1YOuT19/brY+9Du9ZNZ9H5FzGhIPZ36/pb+0gna08OWXtypPLa+6Nn1MXwCwY6FhkWKoQQiTDsgU5paSn19fU9rquvryc3NzdiNgfAarVitVr7XG82m4d0AhHp/jm20NBQk98Nw3CC0mIPlX50e9RBPYehPvdkkrUnh6w9OVJ57ZGk0nP55S9/yU9+8hPq6uqYN28ev/jFL1i0aNGA9/vTn/7ETTfdxNVXXx1TJ9HhYvQGsmdmyegIIUQiDHuj/iVLlrBx48Ye123YsIElS5YM90PHJNtmDhsamvgSDb9fpSXQdQ2kIYEQQgyH559/ntWrV3PvvfeyY8cO5s2bx4oVK2hoaOj3fidOnOCuu+7i/PPPP00rjc7o0/ZzKpLREUKIhIg70Onq6mLnzp3s3LkT0NpH79y5k6qqKkArO7vllluCt//a177GsWPH+Pa3v82BAwf41a9+xZ///Ge++c1vJuYZDFGO1YRTDbSYdic+0OlwevD6Q4NIJdARQojEe+SRR7j99tv5whe+wKxZs3jiiSfIzMzkqaeeinofn8/HzTffzH333ceUKVNO42ojM+mBjlUCHSGESIS4A51t27Yxf/585s+fD8Dq1auZP38+99xzDwC1tbXBoAdg8uTJrF27lg0bNjBv3jwefvhhnnzyyaS3ltZlW03YCQxnG4aMTnNYNgegzS6BjhBCJJLb7Wb79u09OnwaDAaWL1/O5s2bo97v/vvvp7i4mC996UunY5kDsvq1QMdgzU7ySoQQYnSIe4/OsmXLUFU16ueffvrpiPf56KOP4n2o0yLbZsKhDw0djkCnq2egIxkdIYRIrKamJnw+X8QOnwcOHIh4n3fffZff/e53weqEgZyOsQcWvwMUUE22Ed/WO5Xbqcvak0PWnhypvPb+xPp8RmTXtdNJn6MDgMeR8OM3d7l6XG5zuKPcUgghxOnQ2dnJ5z//eX77298yZsyYmO5zOsYeWPxOMMKxyhpq160b9DFPp1Rupy5rTw5Ze3Kk8tojiXX0gQQ6VlOw65o+rC2RmnqVrnVIRkcIIRJqzJgxGI3GiB0+S0tL+9z+6NGjnDhxgquuuip4nd/vB8BkMnHw4EGmTp3a4z7DPfbA4/PzwbZHAJg5dyHzz10Z9zFPp1Rupy5rTw5Ze3Kk8tr7E+voAwl0bCaaGL6MTkugdE1RQFVlj44QQiSaxWJh4cKFbNy4kWuuuQbQApeNGzdy55139rn9mWeeye7du3tc973vfY/Ozk5+9rOfUV5e3uc+wz32wOnzkKU4tcfKyk2ZE5JUbqcua08OWXtypPLaI4n1uUigYzVRrXdd8yQ+o9PcrZWulRdkUtVilz06QggxDFavXs2tt97KOeecw6JFi3jsscfo7u7mC1/4AgC33HILZWVlPPTQQ9hsNmbPnt3j/vn5+QB9rj9dXF4/GWh/L8w2aUYghBCJIIGOLax0bVj26GgZnSljs6hqsUtGRwghhsGNN95IY2Mj99xzD3V1dZx99tm89tprwQYFVVVVGAzDPjpu0JweH5mBQEfm6AghRGKkfaCTYx3mQCeQ0ZkyJptNBxsloyOEEMPkzjvvjFiqBrBp06Z+7xupY+jp5PL6yQyUriGBjhBCJMTIfXvrNMm2mbCrw9eMQM/oTC3W/nBJoCOEEKK38IyOBDpCCJEYEuhYTTiDc3SGI6MTKF0bo9Vcd7m8eHz+hD+OEEKI1OX0hPboYB58u2ohhBAhaR/o5FjN2LEB4E9wRsfnV2m1h/bo6KTFtBBCiHButxOr4tUuSEZHCCESIu0DnSyrEUeg65rqjm34UKxa7W5UVWstXZRlIceqbYlqk0BHCCFEGK8j7I02CXSEECIh0j7QMRkN+E2BMgFPYgMdfX9OQaYFk9FAXqbW81v26QghhAjndXUB4MMARkuSVyOEEKND2gc6AAarHugkdo9Oc5dWb12Ypf3RyssIBDrSYloIIUQYr1PL6LgUm1YGIIQQYsgk0AGMgTIBJcEZnaZAI4KiQKCTLxkdIYQQEfidnQC4DBlJXokQQoweEugARpuW0TGoXvAlLghpCWR0xmRr7av1jE5boEFBOupwelBVNdnLEEKIEcUf2CPqlkBHCCESRgIdwGwL2/iZwM5remvpUOma9m+7w5uwx0glW441c/Z963nsjcPJXooQQowoamCPjsdoS/JKhBBi9JBAB7BZM/CqgZcigft0mgLNCIqye+7RaXOkZ0ZnZ3UbfhU+PNGS7KUIIcSIogZKpz0GmaEjhBCJIoEOkJ1hxoFWXpbIzmst3VrpWlGgdC3d9+i0BpowNHS6krwSIYQYYQLVBD6TlK4JIUSiSKADZFtN2PVAx96csOPq7aWLpOsaENqb1CiBjhBC9KAE9uj4jBLoCCFEokiggxbofOSfpl3Y80LCjtvcu+taRrpndLTXo93hwenxJXk1QggxcijeQKBjktI1IYRIFAl0gGybied8F2sXdj2XsH06TV09S9dCe3TSNdAJPW/9tRFCCAHGQNm0as4a4JZCCCFiJYEOkGM18Y5/Ds2mEnC2wb6Xh3xMt9dPp1PrrjZGb0aQ5nt0wttqyz4dIYQIMfq0QMdvltI1IYRIFAl00DI6fgz8M/Ny7Yrtvx/yMVsCZWtGg0KuTQtw8jMD7aXt6TlLJjyjI/t0hBAixOgNVBJIRkcIIRJGAh0g26oFImtNy0ExQtVmaDgwpGPqpVmFWRYMBgUIla65fX6cHv+Qjp9qVFWVjI4QQkRhCmR0sEigI4QQiSKBDlozAoBqbx7MuEK7cscfhnTMll6NCACyLEZMgaAn3WbpdLt9eHyhLJZkdIQQIsTs0zI6igQ6QgiRMBLoADk2LdDpcnph4W3alTvXgMc56GM2B2fohAIdRVFCLabTbJ9Oa3fPwK6xc/CvrRBCjDZmv/Y70WCVrmtCCJEoEugQyuh0ubww9WLIKw80Jfj7oI8ZmqFj7XG93pCgLc1m6fR+vpLREUKIEItfy+gYrNlJXokQQoweEuigNSMALdDxY4AFt2if2P70oI/ZpAc6YRkdIH0zOvaeGR3ZoyOEECFWVQt0jDYpXRNCiESRQIdQRgeg2+2F+f8SaErwPjQeHNQxW/TStayegU5waGiaZXT0QEd/rSWjI4QQIbZA6ZpRMjpCCJEwEugAVpMBs1FrEtDl8kLueJiut5oeXFOCYOladq/StTTN6Oila9NKtD/ijZ0u/P70a7EthBCRWNHe/DHZJNARQohEkUAHrUmAnmnQh3wGmxLsGlxTgqYIXdcgNEsn3bqu6RmdacXaH3GvX6UtzYI9IYSIJlPV/s6YM3KSvBIhhBg9JNAJKM3TplEfru/SrjjjEq0pgaMV9r8c9/Gau/Suaz0zOrlpntEZm2OlMBD8NUjnNSGEQPX7yUAPdCSjI4QQiSKBTsDiyYUAbDnerF1hMA6pKUGkOToQ2qOTbl3X9IxOQaaFsYHgr6FD9ukIIYTb7cCoaKW8FsnoCCFEwkigExAMdI61hK6c/y+gGKDyPWg8FPOx7G4vdrcPkK5rutZAYJefaaE4Vwt0pCGBEEKAy94V/L8tUwIdIYRIFAl0AhYFAp2D9Z3BbEyPpgQ7Ym9KoDcisJgMPTq6AeRnpmeg0xbM6JhDGR0JdIQQArejAwCXasZsNid5NUIIMXpIoBNQlG0NbpTfejwsq6M3Jdj5bMxNCcLL1hRF6fG5vDQtXdNfk/xMC2MloyOEEEGeQEbHgbXP3wwhhBCDJ4FOmMVTeu3TAThjOeROCDQl+EdMx2nWZ+j0KluDdM7oaM+3Z0ZHmhEIIYTHGQh0FOsAtxRCCBEPCXTCLJ5cBPTapzOIpgRN+gydrL5/tPSuax1OT9rMkXF7/dp8IrRmBMW5NkAyOkIIAeALBDpOMpK8EiGEGF0k0AmjZ3T213XQHl5aFmxK8C40HR7wOMFhoVl9Mzp66Zqqhs3sGeX07JWiaIGentGRQEcIIcAbCHRcBluSVyKEEKOLBDphinNsTBmTharC1hNhWZ28Mpi2Qvt/DFmdln5K16wmI5kWI5A+Q0P1srW8DDNGgyJd14QQIozf1Q2AS5FARwghEkkCnV4WT9HL15p7fuKcL2j/7lwzYFOCYEYnO3K9dbq1mG51hGboABTnaK9Lp8uLI9CGWwgh0pUvEOi4DVK6JoQQiSSBTi+fCDYkaOn5iTOWQ24ZOFoGbErQFOgwVhihdA3Sr/NaW3CGjva8s60mbGbtW0+yOkKIdKe6tNI1j1ECHSGESCQJdHrRGxLsPdVOhzMsEAlvSvDBr7RNNlHopWtjIpSuQfpldEId17TXQ1EUinO0Eg3pvCaESHeqxw5IoCOEEIkmgU4vpXk2JhZl4ldh+4nWnp8850tgyoBTO+D4W1GP0dxP1zUIZTba0iTQae0V6ACMzZF9OkIIAYBbK13zSaAjhBAJJYFOBIsna+VrHxzvtU8ne2woq/POIxHvq6pq2B6d/jM6HWkS6OgBXUFmaOK3vk+nQQIdIUSaUzxaoOM1ZiZ5JUIIMbpIoBNBxHk6uqX/DgaTltE5ub3PpztdXtw+P9BfRkcLgNrs6dV1rSBLMjpCCNGb4nEA4DNLRkcIIRJJAp0I9Hk6u2va6Xb1mnWTXw5zPqv9/92+WR39xD3baiIj0Ea6t/Tbo6MFdPkRMzqyR0cIkd4MgT06fpNkdIQQIpEk0IlgQkEmEwoy8PlVtlW29r3BJ78BKHDgFWg40ONTTYFAR89YRJJ2XdccskdHCCGiMXq1QEc1ZyV5JUIIMbpIoBNFqHytue8nx86AmVdq/3/vsR6fauwKBDpRZuhA+mV0Wnu1lwbCuq5JoCOESG9GnxboYJaMjhBCJJIEOlEsjjZPR/fJ1dq/u/8CbVXBqxtjyOjoJ/zpEuj0bi8NoddHAh0hRLoz+bQ9Olgk0BFCiESSQCeK+eX5AByq64x8g7IFMGUZ+L3w/i+CV8cS6KRTRkdVQ88zPNDR9+g0d7nw+aPPJBJCiNHOHAh0FIuUrgkhRCJJoBPFuHyt+02ny4vd7Y18Iz2rs+OP0NUAhAKdaMNCAfIz9K5roz/QcfrAGwhkwkvXCrMsKAr4VWjulqyOECJ9mYMZnezkLkQIIUYZCXSiyLaayAp0TWvoiHIiPvkCKFsIXid88GsgbI9ODBkdh8eHy+tL4KpHnu5AjJhhNmIzh7rQmYyGYPttaUgghEhnFr/WfdJoldI1IYRIJAl0+lGSq22Yr++I0gJZUUJZnQ+fBGd7TKVrOTYTiqL9f7SXr+mBTviwUJ0MDRVCCLCoWkbHaJOMjhBCJJIEOv0oztVOxOv7OxGfsRLGngmuDvjwd6FAJ9sW9S4GgxLM6nSM8kDH7tEiuvzMvqV80mJaCJH2VD82VfsdaLRKoCOEEIkkgU4/9IxOQ7SMDoDBAJ/8JgDqB7+iq7sL6D+jA+kzSyeY0cmKntGRQEcIkbYCw0IBjBkS6AghRCJJoNOPAUvXdLOvh7wKlO5GrlM2AVDUTzMCgPw06bymBzqS0RFCiAjcoUDHLHt0hBAioSTQ6YeecaiP1oxAZzTDef8BwNdM/6A404DZ2P9Lm5s2GR2tdK3/PToDBJJCCDFaBTI6dtWKzdL396QQQojBk0CnH8WxZnQA5v8LblsRE5QmbrBuGfDmeoaj1e4e0hpHOj2OK4iY0dFeX8noCCHSlrsbgG6s2EzGAW4shBAiHhLo9KMknq5g5gwOTf48AKs8L4Df3+/Nywu0OT0nmruHtsgRrr/SNb3Zg3RdE0KkKyWQ0XGoVqxm+ZMshBCJJL9V+xG+R0dV1QFv/+GYa+lQM5jgrYRDr/Z72zOKtU2nh+u7hr7QEay/9tJjs2WPjhAizemla9h6zBoTQggxdBLo9EPPONjdPrpc3gFvX+Ow8IzvUu3Cxgfg5Laot51WnAPA0cbRHujoe3SiNyOI9fUVQojRRnVpWX07Vmwm+ZMshBCJJL9V+5FpMZFjMwExNCQAGrtcPOW9ArcxGxr3w5OXwJOXwt4XwdfzRH5qcRYATV1uWrtH7z4de7B0rW9GJ8tqIsuivYMpWR0hRDryOjsBrRmBVTI6QgiRUBLoDCCmWToBjZ0umsnj7QvXwLxVYLTAya3wl9vg52fDez8HRxugBVFl+do+nSOjOKvT3U8zAgg1fIjl9RVCiNHG69QyOg5sktERQogEk9+qAygJlK/Vx9ACualLy0rYxp0F1/4avrEHLvwOZI6B9mrY8H14ZBas+zY0H2Vayejep+P2+nH5o5euQah8TRoSCCHSkdelBzpWTAOMJRBCCBEf+a06gJIcvSFBDKVrgZN1/eSdnBK46D/hm3vh07+AsTPB0w1b/xd+sZC72x9gLK0caRidgU5bYBiqQSFYAthbzENZhRBiFPK7tN//LkNGklcihBCjjwQ6A4h1lo7b66c1MDQmGOjozDZYcAv822b4/Esw7TJAZUbb2/yv5VGO1bcMw8qTry0wIygvw4zBoES8jV6+V9PmOG3rEkKIkcIfyOi4DbYkr0QIIUYfCXQGoJeuNQyQ0Wnu1j5vMijkZ0SZbq0oMPUiuPkv8LV38VpyWWA4wpWnHk/omhOt0+nB4+t/LlAkeuAXqbW0rixf++Ne0yqBjhAi/aiBgaEeyegIIUTCSaAzgGAzggH26Ohla2OyrVGzFz2UzsF15a8BuMH/Ko5tzw5tocOkqtnOJx7cyDf+tDPu+7YFAp1Iw0J14wMZnVPtEugIIdKP6tbm6HiMEugIIUSiDSrQ+eUvf8mkSZOw2WwsXryYrVu3Rr3t008/jaIoPT5sttRJ0RcHytAG2qMTDHRyop/U95Y190qeNNwAgPXV1VC3Z5CrHD4b9tfT7faxYX993FkdfY9O1AwXYYFOm+zREUKkIU8goyOBjhBCJFzcgc7zzz/P6tWruffee9mxYwfz5s1jxYoVNDQ0RL1Pbm4utbW1wY/KysohLfp0Ct8sr6pq1NsFGxFkW6PeJpJ/ln6Rt31zMPic8OfPB9tPjxRbjjUD2h6kQ/Wdcd03lNHpp3StQPvj3tLtxu6WoaFCiPSiBDI6PmNmklcihBCjT9yBziOPPMLtt9/OF77wBWbNmsUTTzxBZmYmTz31VNT7KIpCaWlp8KOkpGRIiz6d9MYCLq+fDkf0E/E+HddidEZJHv/huZN2Sym0HIOX/g388e+HGQ5+v8rWE6FGCbtPtsd1/9ZAM4L+9ujk2szkWLWObJLVEUIMRTzVBr/97W85//zzKSgooKCggOXLl/d7++Fi8GqBjt8sGR0hhEi0yD1/o3C73Wzfvp277747eJ3BYGD58uVs3rw56v26urqYOHEifr+fBQsW8OCDD3LWWWdFvb3L5cLlCpWKdXR0AODxePB4PPEsOXi/8H/jYUQrvWpzeKhp6SLTnB3xdg0d2h6TokxzXI8zuSiDNnL4WeF/8f3Gb6EcXIvvnUfwL/36kNc+VAfqOoNZGYCd1a1cP39czPdvDswVyrEa+13/uDwbnQ1dVDV3MrEgvkBxuCTzdR8qWXtypPLa+5Mqz0evNnjiiSdYvHgxjz32GCtWrODgwYMUFxf3uf2mTZu46aabWLp0KTabjR/96Edcdtll7N27l7KystO2boMnkNExZZ22xxRCiHQRV6DT1NSEz+frk5EpKSnhwIEDEe8zY8YMnnrqKebOnUt7ezs//elPWbp0KXv37mXChAkR7/PQQw9x33339bl+/fr1ZGYOPr2/YcOGQd0vAyNtKPxj4zucmR+5fG33YQNgoKHqCOvWHY752E3tCmDk5dpCPl1xM2dX/x7DP/+bD6rdNOWEgsHBrn0o3qrV1mZSVLyqwnv7qllnOhHz/Y9Uaa9J7YnDrFt3KOrtTG7tdq+/8yGdh6KXByZDMl73RJG1J0cqrz0Su92e7CXEJLzaAOCJJ55g7dq1PPXUU3z3u9/tc/tnn+3ZAObJJ5/kb3/7Gxs3buSWW245LWsGMPi0N8lUyegIIUTCxRXoDMaSJUtYsmRJ8PLSpUuZOXMm//u//8sDDzwQ8T533303q1evDl7u6OigvLycyy67jNzc3LjX4PF42LBhA5deeilmc/Qyqmj+0rid2iPNTJo5l5XzI7/T98yprdDSxoWL53PF7NKYj93c5eLxfW/R7FaY+rmH8L/uxPDxcyw99Tu8X3oTT8bYIa19KNY+txNo4PqF5Ty/7SR1TgOXXHYpVlNsFY9PV38ArR0sWTiXlXOjv0O6xbePfVtPUlQ+jZXLz0jM4odoqN8zySRrT45UXnt/9Iz6SDbYaoNwdrsdj8dDYWFhxM8PV6WB0avv0clImewZpHYGU9aeHLL25Ejltfcn1ucTV6AzZswYjEYj9fX1Pa6vr6+ntDS2k3uz2cz8+fM5cuRI1NtYrVas1r4lTGazeUgnEIO9f2me9k5bU7c36v2burT9KKX5WXE9Rkm+ifxMM212D9XtHmZd9Sg07EGp2435xS/Bv/x9SGsfLL9f5cMTrQB89txyXt9XT5vdw/FmJ3Mm5MV0jHantqdpTE5Gv2ufUKiVbNR1ukbcCeLpft0TSdaeHKm89khS4bkMptqgt+985zuMHz+e5cuXR/z8cFUaGAJzdOqaO1m3bt2gj5MsqZzBlLUnh6w9OVJ57ZHEWm0QV6BjsVhYuHAhGzdu5JprrgHA7/ezceNG7rzzzpiO4fP52L17NytXroznoZMqNDQ0+mb5wTYjUBSFacXZfHiilcMNncwaXwaffQZ+cyGc/BDDhu8DFw567YN1uKGLVruHDLOROWX5zCnL453DTXxc0xZzoKMPDO2vvTRAWbDF9OiYpeP3q7HNUhJCjAj/8z//w5/+9Cc2bdoUdfzBcFUaWNH+doybOJWVK5cNav3JkMoZTFl7csjakyOV196fWKsN4i5dW716NbfeeivnnHMOixYt4rHHHqO7uztYF33LLbdQVlbGQw89BMD999/PJz7xCc444wza2tr4yU9+QmVlJV/+8pfjfeikCbWYjjxLp9vlpdvtA2BMduxzdHRnBAKdIw1d2hWFk+Ha38BzN2Lc/jtmj63G8OFJyCwAay5uUzaWbO3/2PK0f42JrUL8INBWeuHEAiwmA3MnaIHO7pPtsHjg+/v9Ku36HJ1+uq5BKNCpGQWBzn889xHbTrTw2jcvINc2en6hCDGSDaXa4Kc//Sn/8z//wxtvvMHcuXOj3m44Kg0U1YdJDZSw2bJT8iQklTOYsvbkkLUnRyqvPZJYn0vcZ8c33ngjjY2N3HPPPdTV1XH22Wfz2muvBUsGqqqqMBhCezhaW1u5/fbbqauro6CggIULF/L+++8za9aseB86aYpzAoFOZ+SMTlOgu5jNbCDbGn/AcUZxDkAo0AGYcTlc8G14+8dMbVwP69cHPxUxlMorhysfhWmXxv34kWw5rgU6n5ii1avPKcsH4OMYW0x3Or34A30F8jP7D/70oaF17U58fhVjimZDHG4fa3fX4vOrfFzdzienjUn2kkSC/PNgA8U5Vs4aH1s2U5xeg602+PGPf8wPf/hDXn/9dc4555zTtNoQoz/05pnBGrmjpxBCiMEbVBrgzjvvjPrHY9OmTT0uP/roozz66KODeZgRI1S6FjmjE162pijxn6RPK9b+wB0OD3QAln0XX+YYqj9cS0VxPgZ3J8dO1uJ3tJOj2MlVHGQEyh5or4Znb4AL/h8suxsMxrjXoVNVlS3HtPk5i6cUATA3UK52qL4Tp8eHzdz/8RsCQWGGUR2weUFxjhWjQcHjU2nqcgUzaKlm76l2fIHorrKlm08igc5ocLLVzhef/pDSXBub774k2csRUcRbbfCjH/2Ie+65hzVr1jBp0iTq6uoAyM7OJjv79AQdJp/2e9KrGjCZR0ZrfSGEGE2GvevaaKCfeDd0OiPuv9AzOmOzB/eH6oxAoHOiqRuPz4/ZGAgMDEb8C7/IrvpSylauRDGZuOG/36DF7Q42MLAafNx1filf8j2PYduT8PZPoHorXP87yB7b7+PWtTvZdLCBa+aX9QhcjjR00dztxmY2BAOccXk2xmRbaOpys7+2g/kVBf0e+3iTtsF2TAwxi8looDTXRk2bg5OtjpQNdHaFZbuqWuJryev0+KjvcDKxSGZpjDTHGrtRVahtd9Lu8JA3wJ4zkRzxVhv8+te/xu12c8MNN/Q4zr333ssPfvCD07JmPaNjx4rNIn+OhRAi0WLrE5zmxgQCGI9PpdXu7vP5wTYi0I3Ls5FlMeL1q1Q2d0e93eGGLloCAcib31rG1WePx+U38sO3Gll16ga81/wGzJlw/C343wug6oN+H/fBdfv57gu7+c7fPkZVQ/NrPjiuZXMWVBRgNWkBkKIozCnTgp7dNQOXr+mBzlhbbHNxRkNDgo9PtgX/X9UcX6Dz3b99zLKfbmLtx7UJXpUYqvDvyXi/ruL0uvPOO6msrMTlcrFlyxYWLw5tKNy0aRNPP/108PKJEydQVbXPx+kKcgBMgUDHgRXrAFlyIYQQ8ZNAJwYWk4GiLG2fSaSGBEMNdBRFCWZ1Dtd3Rb3dlrAGAYVZFn72ufk8euM8sixGPjjWwgbjBXD7P2HMdOg8BU9/Cjb/EtTIwYZ+Yv73nad4/sPq4PV6I4JPBMrWdHMm5AfuN3CgcyIQsI2NcQbe+Hwti5Pagc7gMzq7TrajqvD9v++huStyiaRIjvDvycqW6G9ECBEvPaPTrdpink8mhBAidvKbNUbFudEbEjQGS9cGX3IVsSFBL3qmZfHkUABy7fwJXD57XOi+xWdqwc7s68Hvhdf/E/58Czh7tuGzu71Uhp2M3/vyXg7WdfbcnzO55+C8YEYnhkAn3ozO+BTvvNbu8ASfM2jv/KtRAszeVFWltl173i3dbn7wj33DskYxODVtoZ/5SsnoiAQKz+gMtO9RCCFE/CTQiVF/s3SGmtEBmFYSpSFBQHgA0jvTMrVY29dxtDFwX2u2tkdn5U/BYIb9L8NvlkHdnuB9DtV3oapaO+wLp4/F5fVzx5od7KnpoKnLhc0E80qt4GiDrgZoq2Z+VjMzlCpsjbtwVu0Avy/q8znRpJ0Qxly6VpDapWt68Kd/n3S6vLTZY5va2+7w4PT4ATAaFP6x6xSv760bnoWKuEnpmhguPfboSEZHCCESTnY/xqgk0GI6Uue1RAQ6Z4zVAp1oGZ3jTXaaulxYTQbmlfdscavf92hjWFmNosCi22H8AvjLrdByFJ68BMbPB5+biZ3drLd0kovK2FYDrbYujO1eLE96OWT1YFF88OOeaxgDvK4/xaeAomlw4be17FFYlze720tdICAcG2OSK5TRiT6UdSTbFSgDPGdSIdtPtFLX4aSyxU5B1sBzlWrbtedclGXhs+eW8+tNR/neS3tYPLlwwNbcYvidapfSNTE8TL5AoKPaZI+OEEIMA3kLKUb6O/URS9cCgc5ghoXq9IzO0cauYIvicFtPtAIwvyI/2CBAN7U4dN8+5VITFsJX34YzloPXCVWboWY7BR0HmG6oodR7CmPnScbQRoHSRRZOLcjpzWgFay4dhnxq1CLcxixoPgwv3A6/XAS7ngefFwhlc/IzzGTF2KAq1ZsR7KpuA2DehDwqijIB+m0sEa4uEOiU5tn4+iXTmDo2i8ZOFw+8sn9Y1ipi5/er1IYF35LREYlk9GvfW5LREUKI4SEZnRgF9+j0yuioqkpTl9aJbSgZnQkFmVhNBlxePwfrOpk1PrfH57dE2J+jqyjMxGRQsLt91HU4GZfXqwNAZiGs+ovWjc3VAUYLD75+hI/rnHxl2QwuPmsCGC0882Etv3m/Go9q4hef/wTnTi0Fkw2MZi1DBPz+jcM8+sYhbppRwEPlm+H9X0DzEXjxK/D2j+GC/0cl5wEwaUwmEFvgomd02h0eulzeQQ1eTSa9EcHcCfkcqu9i6/EWqmNsSKBndMbl2bCZjfz4hnnc8MT7/G3HSa6cN46LZhQP27pF/5q6XLh9/uDl2g4nLq+vz5sNQgyGKax0bZxkdIQQIuHkLaQYBWfp9Nqj0+HwBk+Exgxyjg5oezOWzdDm3jz9/vEen1NV+DCQ0Vk8pbDPfc1GAxMDWYSjDVGyCAYDTL0IZl2NOv1y/tI2gw/8syg+60IoWwCls1n1qeV8YsFCZp05k3kzzgBbLpgswSAHQoNDP6zzwPnfgm/shkvugYyCQMDzVZa8tpJrDe8wpSD21yPbagrOJ0m1rE5Dh5O6DicGRWvYMLFQz+jEFujUBUqjSvO077GFEwv44nmTAfjei3siZvhSjaqqPLe1ij0xtCYfSfTmGKW5Wgt4VYXqluH//nzo1f38y5Nb6HZ5h/2xRPLoe3QcqhWbWf4cCyFEoqXW2+ZJFCxd65XRaezSAp9cm2nIXXO+csFUXt9bz0sfneKuy2YEs0hNTqjvdGExGlgQZVDn1LHZHG3s5khDJ5+cNqbfx2nodNFq92BQQsNKQQu2fvKZef3ed3ag89rRxq5A5iVHC3gWfQW2/hbe/wX5jioetfya1qp/0JIzC8O6jeBzgscOHof24e4O/d/nBpOVlxWVNouJ4r8WQm4emDO0D5NNmw804VyYeaV23QiiDwo9ozibLKspWLoWa4vpU8GMTuh53XXZDP68rZqaNgcfn2wbcEDrSLe9spW7X9jN9JJs1n/zwmQvJ2anAmVrZQUZ2N0W9td2UNXS3ePnJtHqO5z85u1jqCq8tqeO6xdOGLbHEskVbC+NDZtkCYUQIuEk0ImRntFp7HLh86sYDVqWoyEBjQh0CycWcM7EArZVtvL790/wncvPBOBIh/ZY88rzogZTU4uzYV99z4YEURyo6wRg8pisuIOzsTlWxuXZqG13sremncV6BzhrDpy/Ghbdzv/94vus7PwLhc6TFDhPQmNsx54ITDQAjcci32fr/4ItD+Z8FhZ8Hsb1H5SdLvo8ormBOUMVhfEFOsE9Ormhzg0ZFiPnTR3Da3vrePdwU8oHOnqTjSMNXTg9vqjfdz9/8wgv7DJy3kUexphj3OA1jPTsYll+Bm6vn/21HcPeYvrV3bXB0VfrdtdKoDOK9RwYKhkdIYRINAl0YlSUZcGggM+v0tztojjQhS0RHdfCfeWCKWx7Zjv/90Eld1x0BlYDHA0EOpH25+imjg01JBjIgVptps6Z43IHuGVkc8ryqG138vHJsEBHZ83hMeeneNB1PusvrMRxfBtTzpyN0ZYTyNBkhn1kgCVTa4HtdfH7t/bx9r5qrj6rgGtmFwUyQIFMkKMV9r0M7VXw4W+1j9K5sOAWmHODVjqXJHpGZ16grE8PdOo6nP2e1Ov0GTrj8nq2qPvkNC3QeedIE/9+ybR+j+H3q7Ta3TR0ujjV2k3NCGsOpgd9flULdvTMYDhVVXnmg2raHApbj7eycl7m6V5mH3rp2vj8jGCjj+EOdF75uDb4/3cON9Hh9JBrS37QJxLPGOy6ZpWMjhBCDAMJdGJkMhoYk22lodNFQ0ekQGfww0LDLZ9ZwpSxWRxr7OZPW6u49RPlwYxO7/k54aaO7TVLpx96RufMkpxBrXFeeT7r99Wzo6q1z+c6nJ5AcwYbWef/K9vd65l0/kqMMbw77y4v5J97DpBnHM818+b3vcGlD8DxTbDjGTjwCtR9DOvugtf/C2ZepWV5Jl2g7Uc6TVRV7ZPRKcyykG010eXycrLV0W+ZkzYsNNR1Ldz5gRLEj6paozZo2LCvnvtf2UtduxOPL7SXx6gYuWK5g8nFI+MEOTy7dbCuM2KgU9fhpM2hzR46OUL2aYUyOjYMgSxurJm6wahtd7CtUvu5Ks21UdfhZOP+eq6dL1md0cigBzrYJKMjhBDDQH6zxqE4uE8n1JCgsSsQ6AyhEUE4g0Hh9vOnAPDUu8epbLbT6lYwGRQW/P/27jw+qvJ6/PjnziQzWSb7ngBJIGHf1wYRVEAWQZa6WwtqURT7rQtatRWrtoW6UJda/bXWpVVcK2LrUpEdZIeAQIgsCQRICEkI2ZPJzPP7485MEpKQPZPE83695gWZuXfmzEwyd859znOe2MB693O2mD5bUE5h2aUXqnQlOs0c0RkdrzdE2JmeV6uddXqOPpQQajE3uXNa1Vo69XzJNRig11Vw/VvwUCpM/RNEDARbORz4BP45C14aoic+J7eB3V73/bSijLxS8kuseBo1+kbpiaOmaXR3la9demilsLySkgq9nffFiU5siC/dg72x2hTbj+fWuf8L36SSkVfqSnJCfE34mo3YlMaGHxpZM9gOMs5Xvac/nC2sc5sUx0jjxdu7k3MNnehAb2KD9ZMJjW0b3hxfOEZzRsUFccPIbo7rZPHYrsrgbC8tIzpCCNEmJNFpAueiodUbErR26RrAnGExhFrMnLlQxu8ca6kMivHHx1R/4uDv5Um4I4bjl5inY7XZOZrtSHQimzeiM7hbACYPAzlFFRzPqflYaY6f40ObXnYU7VpLpxGLhvoEw08WwsLNsGAdjLwDzP56advWv8CbU2B5X/jvg3BsHdgunfw1l3Oh0H5R/jVaDjs7rzW07opzfk6At2ed7++4BL0T36YjObVuS80q5HBWIZ5GjW8fnMAPv5/G7icms/ByvWPb5qN1J0fuUL3Vdmq9iU7V9afOd4z1ak6fr5boOJpMZJwvxd5GnfCcZWszBkczfXAUABuPnGvw5IXonJylaxUGb9eIoRBCiNYjiU4TOLugfbrnFItW7OGalze5vpi0ZLHQi3l5Gpk/Nhao+rI6Oq52W+mLNWaezvFzxVhtCovZg25BzeteZvYwMqx7IAA7HOv7ODkXC40L8W3y/TrjySooo9LWyNEYTdPbY8/4sz7Kc+O7MPhGMAdA0VnY9Q/412x4LgFW3gOHv9Tn/bSSqrK1mqVYzi/FJxooc6q+hk5dnOVrm4/WTnQ+Sz4NwBV9wkkIt2ByLDg4LkHfZ2taHtbGvo5tqKi8krziCtfPP2TVnegcqjaic6oDjOiUVFRyvkRPMKIDvYkK8MLDoFFRaSeroPV+h5wy8kpIzshH02DawEj6RPjRM8yXiko7aw9nt/rjCfdzdl2rNHasTpJCCNFVyBydJoh2fBl11tA7BXh7MqoRiUhT/Ownsfx1/TFXWdPo+IYn2/cK92Xr8VxXh6u6HM7Sv0z2ifRD05p/BnFMfDDb0/LYmZbHzaN7uK5Pd5T1xIc1PdEJs5jxNGpYbYrswnLXCE+jmXz0uTr9ZkJlBWeS/8fGVW9ytXEXwWX5sG+FfvHwBrMF7DZQNn2hIuf/Hf96KjszNE8MR8PANwR8QsEnBHwd/zoulccySTIUMsmrBI7lAAqUndG2s6Qa0gg8dRxSMyAoDsL61FiTCKrW0Kkv0RnbKwSDpk/gz7xQ6mpBbbcrVu3VE505w2Jq7NM/yg9fD0VxuY3kjPxW/91sKudojrenkVKrjTMXyrhQanWtm+SUclGio5Rq0e9oSzlHFv2qrfHULcib9NwSTuSW1Pr9fH3Dcf6+y8iAMSUkRNaeg9SQL7/XT5qMiQ92nVSZPjCKv6w7yhf7M5k1NOZSu4tOyNl1zerh/sYbQgjRFUmi0wTXj+xOWk4xXiYjPUN9iQvxJS7Ulx7BPq6z6a0l0MfEDSO78/Z36RhQDO8R2OA+jRnRcc3PaWbZmtMoxzyd7ReN6DhL2eKbMaJjMGhEBniRkVfK6fzSpic61XmY+CCvNy9bf8Hj1jv4x5WVXGnfDin/gYJTUNnwiIFRWaHwjH6px5MAJmCb4+IwEZhoAs4C7zuu9IuCnldAzyv1f/0iqjUiqPu5BvqYGNQtkH0Z+Ww+ksP1I7sD+vyoMxfK8DN7cFXf8Br7GAwafQIUe3I1Nv5wrmaicz5dL+U7tlZv5hA+ABIm6peguAZfk+ZwTt5PjLBwrrCczAtlHDlbyMhqcZVW2FzzuwBKrXZyiytatAhvS52p1nHNqUeIL+m5JZzMKyapV1VzELtd8fbWkxRYNVanZDcr0fni+6qyNafpg/REZ/0P5+ptSCE6L2eiY5MRHSGEaBNy1GyCyAAvlt84tN0e767xPfli/xm6m8sa9QWnKtGpf45OaislOsN7BGE0aJzO15OSGMeXQeeX1bjQpic6oK9XkpFX6vqS2VxKKVdZoR0DLx4J48r7lsHUpZB7VF+kVDOAZgSDUf+/wej62Wqzs271V1w1ehAeFQVQkgMluVDs+Lckl5L8bDLOnNEXXo3wR0PTR2w0jXKb4oezRaAZGBjth5Z9GAozYd/7+gUgvD8jbAO5whBHd0v3quCtZXpydeE0FJzhIe9k0j2O0HddMewpBd8wKs4HcZPRjx7xQ/CqOA8eITVGi/oGKvbkwq7UE9D9CBx3JDd5x2u+UOfTIfUL/f8hCdBrIiRMgrjLwHSJ99BWqSeM+Sfh/Am9/bdz1CooHjyqSjmdIzrdg30I9jWReaGM1IsSndSzhdiV3kzBZi0nv0IjI6+kgyQ6VaNtzrlXF7eYPpRZQK6jPK++ZguXciK3mP2nLmDWKpmlbYS//QOKc+k3cC5jg/vxXZ4fa1LOyqhOF+PpSHRUB1sEWQghugpJdDqw6EBvNj88ga+//qpR2zs7r53ILcZqs+NprD3K1NI1dJx8zR4MjAlgX0Y+O9PyiBkWw/niCi442gPrc3SaPj+kwc5rjXTwTAHHc4oxexhQSl/rZv+pfL0FdOil16QBwGql1BSKih4G9bTG/u+uDB75ZD+j44L5aGFSjdsMNjuzn/gam12x/eaJRHgrvRPc8XVwfD1k7ofsQ1zOIS43gW3rcjiSCMXn9KSqmvHAeA+g2HEBLgcu9wTSged+qa8jFNobQhIxBPfkhorvmWM6yLCco/BhtffB4AHdRkOvK/W5TWeS4egayNiuJ4C5R/WFWY0miB2rJz6WcD2ZyT8J+Sf0y4XTeqlfXQweerIT2hvCehN80ochmplefhGUB/qxPvWcK+F2cpat9Y30Iyu7nPwKfSSoTRZKtdsgO0V/zhnbIfeYvvhswkSIH68vfkvdIzr1zb3aeKSqw93hrIZbvF9s9e7D3GtcxQLzavy+qhol1ba8yApgg+dgDm77KQy6D4yN/NguPQ/pm/Xftwun4ZYPmhyXaENK4an0RMfu2bwTQ0IIIS5NEp0OrimdeKL8vVzzIDLySugZVnP9lgslVs44SqV6N3MNnepGxwWxLyOf7Wl5zB4WQ5pjfk5UgBfeJiNWa9MTHefI0OkWTkZ3juZc1Tccs4eBz5LP8O62Ezx7XWCL7hf00aLP953h+f+lArUbEQB4Gg1EB+pleCdyS4iID9aTi15X6hsU50LaBr5a9T6DKvbQjRw4l1J1Bx7e4B8NATHY/GL4+74yTlYGs/CaJApzTrN1xzb6e2aRFJCHln9S/1Lr+OJuBIaCq9VIkSUOS/+r9dbcceNcX+QBffRm/GIouwBpG/Wk5+gavXvd8fX6pT5GEwT20C9egXA+DXKOQEUR5B7RL6lfMBeYawZ2Q4WHHzeYLFQcCIayXuAbBpZwLEetTDFUkmTpze78Es4RwKnWWq+mvBBO7YSMHfprdGoXlBfU3Ob0Lr1xhcEDuo+BXlehZfZAw7tm6Vo93fQ2VmvlffRcEZU2Ox51nGioJfcYbPsrP9v5L7w8y/VzA35RMPouCOkFe/6JOrqGCcb9TMjaj/3Pr2EYMU9fKDfgorV1rGX683O+b5nJoKr9DRZmgV9kwzGJ9mErx+A4GaRkjo4QQrQJSXS6EINBo2eYLwfPFHDsXHGtRMfZ1jcm0LvWRPDmGB0fwt83pbEjTe8Ml+YomWtOxzWnqhbTzU909LI1fV7NzCHRhPuZ+Sz5DJ/vO8NvpvcnwKf5zz01q5Alqw645ib1CPbh9nHxdW4bG+xLRl4pJ/NKXGsPufiGwMC5PPKJL4XlVjbc2YNYssEvAvxj9BEaRymaEdh+YQfrUs8Ra+3LvsKefFmZyIKkeMZe0x+spfoX5pwfIOcI9nOHOXPmDHv8JvCnH6IZN3A4f5o++NJPzCugqpGDUvrIztFv9fk81hIIioXAOD2pCYqFwFiwRNRenFUpKDgDOal60nMulb17dxBTmUG4lo+pspBehkKwZkLKQdduM4GZJiAV5gN4QeUmD9gbrjeA8A3VkyLfsKpmEMoOleX6fCtrGVRWu1jL9Otzj0P2wZpf+AFMFug2Uk9qQhL0BOHoGj1ZO7EFTmzhAeDnZj9Kjo6HoBkQ3p8Eo0YY58nOrdSfq6ZRXF7JbkeDEgMKq01vs55Y38kEpeDEd7D1VUj9ElB4AQftscTNeATf4TdUlf71nwV5abz72jNMrVhNaFEWbPgTbHwOEqfA4Bv0Ebbj6/URw8qLusGF9ob4CfqcMHPLRnFFK6uolixfqkxUCNEiNpsNq7VlLfqtViseHh6UlZVhs9VTzdBBddbYPT09MRpbvr6YJDpdTK8wiyPRKWIyETVuc3Zca+n8HKdRcXpZ0bFzxeQUlbs6rjV3fg5Ujeg0ai2deiRn5HPqfCk+JiNX9gnHy9NA30g/DmcV8smeU9xZT2JyKXa7YulXKby5JR2bXeHlaWDRFQksGN8TL8+6/xBdi4bWs8BkUXklhWWVgEZIj/5grj8ZuTwxjHWp5/jqQJarDbNrvoanN0QO1C+AzWpl95dfYkkczekf9rDpyLmmdTDTNL28LzQRfnJP4/apvm9AjH7pdRVKKW7a9jXllXY2/t9wIrTzzHvlS0K4wLKpkfhVnkcVnWPt7gMEqgsMCihHFZ3FrMrxUJUNNoNotMAeelLjvEQM0OdkOQ2+Qf8377g+l+noWopT1xKiFRJy+gs4rc9j6gnsdEzZUU9paCYLRqM3XxuNWE0+lCsPyuwawR/6gK+nntSg9H+VHYWiMD8X/5KTrofewAher5iKZ68J/HP0mNovaXA8p0c8QtL6Wfw69gi/8F4P6Zvgh6/0S3WWSEfDiwl6ghMgc3o6LKue6JQrDzzrKY8VQjSfUoqsrCzy8/Nb5b4iIyPJyMhwazfQ5ujMsQcGBhIZGdmiuCXR6WISHPN06mox7VyQsU8rJTqBPib6RPiReraQXel5LVos1Kn6HJ3mthf+zz69bG1y/wi8TfqX2duSYvnNygO8u+0Et4+Na/LifP/9PpO/b0oDYOqASH47ox/dgi79PJ3zOU7WU4LlXCzUz+zRYLMJ53o6yRn5ACSGWxgQfekz9KNigzB5GDhzoYxj54pdvxvt6VxhOeWVdgwaREVE4GmMIjs4m205xdwUNZrLE8PIyC3hzu/WYTIaSF50Fa9//DX/76CdQYFWPrktwdEAIkefv1ScU9UQwmAEDy890fMw6+V+Hmbw9OZ8hZGXN54k2x7I0/fdQUhUbOMCDu4JwT2xj7iTkU/8h0H2H3jj8kL8T2+CgkyoKMJeXogBhYaCikK8KKSXAXCuIWoA8hyXi2iAP1CmPPm3bTxv2qZyTMVg0OD1n9Qf4/SBUby2/hjLMwfy8yUPYjp/FHa/DUdX6yNSPa/QE5s6WpiLDqpC/7wswavekyVCiOZzJjnh4eH4+Pi06Muy3W6nqKgIi8WC4eJKhg6uM8aulKKkpITsbH0NuaioqGbflyQ6XcylWkynZrVOI4LqRscHk3q2kO1peVUjOi0qXdNPlxeVVzarvbDdrvjie30EoHqb3tlDY1j65WHScor57lgu4xyJQ2N9czALgF+Mi+e3M/o3ah9Xh64GEp3IetbQqS4h3EKEv5mzBfrk5dnDYhr80PY2GRkdF8zmozlsOnLOLYmOM8mLCvB2NcfoE+nH8ZxiUrMKuTwxzDVClRBuwdNoIMQM5ZhILjBjixqGsRkrxj/zUTKfWvV1hm4q8uHyJu6fU1ROqc3ILq0fPlOmQbX5Nje99h3fn8jkxTkJTEmwsOCNDVzIz+PhK6JJSTnId9keDIoJYNFVieDsxOf4993tGaw+nINn9+FcObwfj/t7ERngRbdAn0uWVA6I9ifE10RucQV7Tp7nJz17w9Q/An9s8msjOgbN6kx0zJLoCNHKbDabK8kJCQlpeIcG2O12Kioq8PLy6jTJglNnjd3bWz/xnZ2dTXh4eLPL2DrPMxaN0itcTzKOZRehlHJdb7erVmstXZ1z7smOtDzXHJ2ezVgs1MnH5EF/RyL2haOhQF3sdsW+jHystppzL3am53G2oBw/Lw/G965KZnzNHswdrpfxvLvtRJNiqqi0syFVn2w+fXDjzyo4S9cy6kl0Mh2LhTYm0dE0jXEJYa6frx0SfYmtqzhHgqpPlm9PzkTHOYkfqhphONswOzuu9XO87/4m8DRqVNqV6zWqLj2nmBmvbOKT3afqfMyj2YV85lhMVX+cpndBc3b9i/T3qtVUoEeoL6V4caTYhwwtitXnI9ij9afX2DnkhIzma/toVhQOdcx5mgF9r4G+06HPNN47348N9iHMuWwIt46JZWK/CAZEBzQ4b8xg0FzJ+eYjOZfcVnQSjtK1UmXG3MrrsAnxY+eck+PjI40+OjPn+9eSOVby6drFxIX4omlQUFZJTlGF6/rT+aUUV9gwGQ3Et2AOzcWcic7BMwUUV9gwaFVf8JvrhpF6N6kPd2bUu82yrw8z69Ut3Pj/trpGRqCq29rUAZGYPWpm/z9zlAatTjlb5xfo+uxMz6OwvJJQi4mh3QIbvV8PR+laTlEFReWVtW53xh3ViEQHYHJ/fWHQpJ4hjX6NL0/Uk6Ntx/Mor2z/SYgZefrrXD3RcZZOpjoSkKpER7/eoFXN1XLuX90nu09x4HQBj326n/2n8mvdvnz1D9gVrpGgI81Y18Y5R6yuRWurr6WzwZFADu8RhJ+XB1GOp3k6v5SCspofzAVlVtc8Oef8tqYYl6AnOpuOSqLTJTiaERRL6ZoQbaazzUkRNbXG+yeJThfj5Wmku2PuSPXytf85Sq+c5UGtJcLfyzUXBfQvhhcnGE01a2gMJqOBQ5kFHDh9odbt54sr+NdWfVRmz8l8Zryyia3Hcqm02fnSubp8HSMevSP8GB0fjM2uWLH9ZK3b67P60FlAb1XdlLk9/l6eBDnO1F/cjhggs8BZuta4xQKnDIjkH/NG8vLNwxodQ78oP0ItZkqtNldnsPoopbDb1SW3aaqTrsVCq56jM9E5crYQu12R4vjy379aSWW3IGeiU/t123NSfx5Wm+KX7++lsFpCceD0Bb78PgtNg3sm9AKat4BnXWvoOPWotpaOc6TMOXLm41GVuF68VtDuE+dRSp+7Fe7fuOS2OmfSuv9UPvklFQ1sLTo8R+laKTKiI4QQbUU+XbugXo7SMWei89aWNH7/hb5Gy7SBrb+OxuhqK9y3xmhRkK+JqwfoHeM+2lV7VOfdbScotdpIDLfQN9KPnKIKfvaP7Tz8yX5yiysI9jUxtlfdNbm3j40D4O0t6ZwvbvjLolKKNYf1RGdSv4gGtq6th2O+Ul0NCZo6oqNpGhP7RRDm1/h5S5qmMd7xJXzV3jN8dyyHbw+dZVXyad7ddoKlX6Vwz7u7mfbSJgY++T+GPv0Nr284RkVl09dAqkvGeWeiU5UMxwb7YPIwUFJhIyWrwDVq06+uROd8zdfN5ihZBPD38uBEbgm//eyAq0zz+W/0tY1mDYlmxhC9zPDI2ZplnI3hLF2LCapjRMfxnh4/V8zWY3pr9fG9q8oK+0Toc6Gci/M67XS0JB9V7e+lKSIDvEgIt6AUfOd4XNGJOUZ0SpQZs4zoCCHaQFxcHC+99JK7w3ArSXS6IGdDgqPZRbz07RGe+s8hAO4cF899VyW0+uNVXyOmJY0IqrthZHcAPtt7mjJrVclVmdXGO1vTAbjvqgRW3nsZc4bFYLMrVjrmZUwdGFnvqNWUAZH0i/KnsLyS1zceazCOI9lFZOSVYvIwNLmBAVRbYDKvdovpzCY0I2iJyx1zlT7clcEtf9/OL/65i199kMxvPzvA/9twnK8OZJGSqZceFpRVsuyrw0x7aWOrzAXJyKud6HgYDSQ4fkc/T9YbR0T6exHka3Jt0y2w7hGdH84WUlxhw9dk5I15ozAaNFYln+GT3afYmZ7H+tRzGA0a90/qTXyoL0aDRmF5JVkFTWtXfvoSIzrO0rWconIKyysJ8vFkYEzVorF9HHOQDl80orMrXR+Jak7ZmpNz5GiTzNPp9DTHHB29GYEcioUQuiuuuIL777+/Ve5r586dLFiwoFXuq7OST9cuqJeju9aHOzP487c/APDg5N789pp+bVKvWj3Raa35P+MSQokJ9KagrNJVdgewcu9pcooqiA7wYvqgKLxNRpbfMISnZw3Aw1FWNusSE/UNBo2Hp/QG4J3v0slu4Avw2sN6adJlvULwMTW9SWFscP0tprMc84QaO6LTXJP6RTAiNoiYQG8Swy0M6R7I2F4hTOoXwfyxcSyZ0Z9/zBvJtw9O4PnrhxBqMXHsXDE/+8d27nl3d7MXby2vtLkSjB4XzSlylq99vk9PdJzzc5y6u0Z0aj723pP5AAzpHsjo+GAemJQIwJJVB1mySl+A9IaR3YkL9cXsYSTOUWbW1IYEzuccE1j7vQn08cTPq+p3YVxiWI3OcH0iHSM61RKd8kobyY75RM0d0YHqic65Jo9SiQ7G2V5aebW43FcI8eOhlKKysva837qEhYX96BsySKLTBTlHdEoq9JGQJ2f25/8mJrbZpLwewT5EOuYctKTjWnUGg8Z1I/SmBM7yNbtd8fdNxwG4Y1y8a9RG0zR+nhTHf345jtd/NoIxPS/dSvLKPuEM7xFImdXOX9YdveS2ax3d1ib1b3rZGlR9wT9x0RydMquN8yX63JIo/8bN0WkuPy9P/n3PWLY8ehWrH5zAqkWXsWLBT3hj3kh+d+0A7hgXz8R+ESSEW7huRDfWPHQFt18Wh9Gg8dWBLK5/fWuzStlOny9FKfAxGQmpNloDVYmOc1Sr30Utz+ubo7PXMT9neA99VOSeKxIY2yuEUquNlMwCTB4G/m9i1ails8NbUxsSXGqOjqZpNealjb9opK+v4zFTswpdycj+UxeoqLQTajG16GTAmPgQPI0ap86X1vqdEp2MjOgIIS4yf/58NmzYwEsvvYSmaWiaxttvv42maXz11VeMGDECs9nM5s2bOXbsGLNmzSIiIgKLxcKoUaP49ttva9zfxaVrmqbxxhtvMGfOHHx8fEhMTOTzzz9vVGw2m40777yT+Ph4vL296dOnT51lcW+++SYDBgzAbDYTFRXFfffd57otPz+fu+++m4iICLy8vBg4cCD//e9/m/lqNY58unZBfSL8MBkNGDR4/voh3H5ZfJs+nqZp/Om6wSy6spdrwnRruG5ENzQNthzNJSOvhLWHszl+rhg/Lw9uGt2j1vb9ovyZ2og5SJqm8fCUvgC8v+Nkve2fC62QfEpvhjCxbzMTHccX4uPnimucgXfOz/H2NOLv3bGWswrw9uTJmQP47y/HEWoxcTq/1NVdrClcjQiCai/U5izvcqov0ckuLK9RuuhsRDCsRyCgd1b7841DCXYkUrf9JJaoas0dEi9qZd0YJRWVriS0rkQHIDa4KlmpPj8HIC7UB0+jRlF5JaccI1I70/X5OSNjg1t0wsHX7MEwR5In3dc6uWrNCLxkREeINqeUoqSistmX0gpbs/dt7Aj8Sy+9RFJSEgsWLCAzM5PMzEy6d9dL+R999FGWLVtGSkoKgwcPpqioiOnTp7NmzRr27t3L1KlTmTlzJidPXrrZ0lNPPcUNN9zA/v37mT59Orfeeit5eXWscH0Ru91Ot27d+Pjjjzl06BBLlizh8ccf56OPPnJt89prr7Fo0SLuuusuvv/+ez7//HMSEhJc+0+bNo0tW7bw7rvvcujQIZYtW9bs9XEaq2N9wxKtIsDHkxULxmDyMDC4Ce2QW2JC7zAm9G69JAf0eR2X9Qpl89EcPt59im2OCdi3jonFYm7Zr25SrxAuTwxl05EcXvz2CC/cMKTWNgfPaygFg2ICmj2PZkC0P16eBk7nl7LnZD4jYvUvqWecZWuBXh22/WW/KH/mDIvh75vS+GzvaSY3cVTLWXZWVyvs3pGXTnSCfDyxmD1cyUJCuIULJVaOOdZqGto90LVthL8Xb98+ii+/z6o1B623ozFAU0rXnK2l/cwe+HvVvb6NM4HtE+FHxEUd1DyNBhLC/UjJLOBwViHdg32qGhHEN79szWl8Yig70vLYfOQctzlapovOR3O2l1ZemGVER4g2V2q10X/J/9zy2IeentKo8veAgABMJhM+Pj5ERuonbg8fPgzA008/zeTJk13bBgcHM2RI1XeXZ555hpUrV/L555/XGEW52Pz587n55psB+OMf/8jLL7/Mjh07mDp16iVj8/T05KmnnnL9HB8fz9atW/noo4+44YYbAPj973/PQw89xK9+9SvXdqNGjQLg22+/ZceOHaSkpNC7tz6FoGfPng2+Ji0ln65d1Mi44HZLctrS9Y41dd7anMaO9Dw8jRq3XxbXKvf90NV9AFi59xRHs2uf8T+QpycgE/uFN/sx/Lw8mTFYnzP0/o6qsyxN7bjmLrOH6Yusrk45W2tdmIZk1LFYqFN0gBd+jmTVy7P22k6aptXqvLY3Qx/NiQvxIcRSs/Pc4G6BPDqtb60EuE+10rXGnlG7VNma09X9I/AxGZnn6OJ3sX7OtYKyCrDZFbtOtLwRgdM4x6jpd46W6qJzsk16mhuML/Iv22QZ0RFCNGjkyJE1fi4qKmLx4sX069ePwMBALBYLKSkpDY7oDB482PV/X19f/P39yc7OblQMr776KiNGjCAsLAyLxcLf/vY31+NlZ2dz5swZJk6cWOe+ycnJdOvWzZXktBcZ0REd2pQBkQR4e3KhVP+SPWtoTK0z6M01tHsgV/eP4JtDZ1m++gf+eusI123lVhupF/REpzltpau7eXQPPtl9iv/uP8MTM/oT4O1Z1XGtjefntFT/KH96R1j44WwRX3+fxQ2jujd6X+faQdXX0HHSNI3ekX7sPnGePhF+NSbzO3UP9uFwViGnHAmTsxGBs3SrMeJCffE0ahRX2DidX0q3oIYnZV6qtbTTsB5BHHq6/rNfzjlIKVmF/HC2kMKySnxNxhprBTXXoJgA19/EvlMXXKOEopMx+5GhwriAJiM6QrQDb08jh56e0qx97XY7hQWF+Pn7YTA0/e/VuxVayPv61jwhuHjxYlavXs3zzz9PQkIC3t7eXHfddVRUXHrpDE/PmpUKmqZhtzd80uyDDz5g8eLFvPDCCyQlJeHn58dzzz3H9u3bAfD2vvT3mYZubyvy6So6NC9PI7OHVnVRW3B56w5zPnR1HzQNvvw+i6f+c5ATuXpp1Na0PCrsGpH+ZgZEt+zL6fAegfSOsFBmtfN5st4Cu7OM6Gia5hrVcbbvbiznSExdIzpQlQxcXLbm5Fz41jnXZ4+rEUFgo2PwNFaNFh1pZPla1YhO89+bvo7ndDizwDU/Z3hsEB6tsFiv0aBxWYLecKM1WoAL93H2+PCSdXSEaHOapuFj8mj2xdtkbPa+TSlRN5lM2Gy2BrfbsmUL8+fPZ86cOQwaNIjIyEjS09Nb8Ao1/Hhjx47l3nvvZdiwYSQkJHDsWNUyHX5+fsTFxbFmzZo69x88eDCnTp3ihx9+aLMY6yKJjujwbkuKw9ekJzx9Lprb0VJ9Iv342Rh9nsNbW9K54vn1/OKdnfxzqz4Ue1XfsBbPodE0jZsdzRPe234SpVS7raHTGmYN1ROdbWm5jW41rZSqNqJTd6Jz1+U9uWZwFHdP6FXn7c6RoIy8Uux2RbJjodCmjOhA0xsSXGoNncZylq6l5RS7kpGRsS2fn+M0LkEvX9t8tOlNIkTHYXUmOlK6JoRwiIuLY/v27aSnp5OTk1PvaEtiYiKffvopycnJ7Nu3j1tuuaVRIzPNlZiYyK5du/jf//7HDz/8wBNPPMHOnTtrbPO73/2OF154gZdffpkjR46wZ88eXnnlFQAmTJjA+PHj+elPf8rq1atJS0vjq6++4uuvv26zmEESHdEJJIRb2LNkMstvGNom9//UtQN4547RXNEnDKXg25RsNh3VGx9c1ad1GizMGRaD2cPA4axC9p26QFZB+6yh0xpiAr0ZEx+MUlXr3jTkQqmVwnK9z3/3esrF4kJ9efWW4fW2W3bul3G+hOM5RRSWVeLlaaBvE5Pd3uHORKdpIzoxLUh0wvzMBPl4Ylew5rBe+zwqvvVKzJzr6ew9mU9hE+dOiY7DmehI6ZoQwmnx4sUYjUb69+9PWFhYvXNuli9fTlBQEGPHjmXmzJlMmTKF4cOHt1lcd999N3PnzuXGG29kzJgx5Obmcu+999bYZt68ebz44ov89a9/ZcCAAcyYMYMjR464bv/3v//NqFGjuPnmm+nfvz+PPPJIo0avWkLm6IhOoS0X1DMYNFfXuOPninjnu3Q+2X0KH0MlP2mFLlkAgT4mrhkUxad7T/P+9pOu0rXOMKIDelOC7Wl5fLb3NAvrGYGpLiNPTxbC/Mx4m5r33jlHgjLySthzIh/Qmw40tfzL2XntSB0NJy6WXVjGwdMFQFWL6+bQNI2+kf5sPZ6Lza7wMGgM6956iU73YB9iQ3w4kVvCtuN5l+yI98am4ySEW0jqFSILU3YwMqIjhLhY79692bp1a43r5s+fX2u7uLg41q5dW+O6RYsW1fg5PT0du91OQYF+XKurKU9+fn6j4jKbzbz11lu89dZbNa5funRpjZ/vvvtu7r777jrvIzg4mDfffLNRj9da5DSSENX0DLPw1KyB7HjsSh4bYsPcirXzN4/Ry9c+33eGnCJ9smD1NV86sukDozAZ9RGplMyCBrevWkOn+c/PmWgUlFW61vEZ3sSyNagqXTtytgi7vf7Oa0opfrvyAIXllQyM8WdIC7sW9o2qGnkaGBPQ7ISvPs5Rnc1H6i9fu1Bi5Q9fpjD/rZ2cL5aRn45EKSUjOkII0cbk01WIOpg8DLTCvPEaRsYGkRBuodSxAKbJw0CQT93rtHQ0AT6eXNVXb7P9WSOaEjTUiKAxfM0ehDgWAv025SxQtVBoU8SF+GAyGii12lzzb+ryn/2ZfHPoLJ5GjeeuG9LixgHVS+xGt9LIYHXOeTqXWjj0u2M5KKWXf3aW0cMfi0q7QqHP/5MRHSGEuy1cuBCLxVLnZeHChe4Or9mkdE2IduJsSvDMfw8B+vycjrpYaF1mD4vh64NZrEo+wyNT+9bZEtrp5CXW0GmKbsE+5BZXUO5oT9WcRMfDaKBnmC+HHa2e62qOcK6wnCdXHQDgvisT6+0E1xR9I6vuY1Rc6yc6Sb1CMGhw/FwxZ/JL62ye4EyCxiWEtvrji5Yps1ZNGpYRHSGEuz399NMsXry4ztv8/Vt+THQX+XQVoh3NHRaDyUP/s4tspfWA2suVfcPw9/Igq6CM7cdzL7mtc7HQbi1MdKonSt2CvAn3a95rVtV5re6GBEtWHeB8iZV+Uf7ce2XDc5Aao3eEH74mI2YPAyPbYK2bAG9PhnQPBOpvM73Fkeg4y9xEx1FRWTUB1+whh2IhhHuFh4eTkJBQ5yU8vPkLp7ubfLoK0Y6CfE1MHxgJtKx9sTuYPYxcM1hf0+jTBsrXMlppRKf6HJ+mtpWurne4oyFBHS2mv9ifyVcHsvAwaDx//WA8W6lm0dtk5L0FP2HFgp8Q5CjBa22XO0Zq6ipfy8gr4URuCR4GjTE9Q9rk8UXzlTlGKc0ehk41siuEEJ2JJDpCtLOHp/Zl1tBo7hwX7+5QmmyOY/HQrw9kUWatuyVkdkGZq3StvtbRjVW9zKwpC4VezDWic1Hntdyicp5wlKzde0UvBkQHNPsx6jK0eyAj2mA0x2lcoj5PZ8vRnFqNFjY5RnmG9QjEYpYq5Y7GWbomozlCCNF25BNWiHYWE+jNSzcNY2BM636pbg8jY4OICfSmqLySNSnZdW6zKvkMdgUjYoOIaGF5XvU1eFoyouNcaPZodhE2R0JQXF7Jwnd3k1dcQd9IP+67KrFFsbrDsB6B+JqM5BVXcOiibnhbXPNzWmctKNG6yh2la16t2NlRCCFETZLoCCEazWDQuHaoXr72WXLd5Wv/3nMKgLnDY1r8eD3DfNE08DUZ6d+CBgE9gn0wexgos9rJyCuhtMLGne/sZGf6efy8PPjzjUNdc6c6E0+jgZ84ytI2Vytfs9kVW445Ep1EKVvriMplREcIIdqcfMIKIZpk9lA9gVmfmk1+SUWN2w6dKeBwViEmDwMzBkW3+LGiA7356y3DeWPeqBYlIkaDRq8wfZ7O96cvcNe/drHteB4Wswf/vGN0q3RZc5dxrvV0qhKdg2cukF9ixc/s0eL1gETbKK+UREcIIdqafMIKIZqkT6QffSP9sNoUX36fVeM252jO5H4RBLTSGkHTBkWR1KvloxK9I/RE5/FPv2fTkRx8TEbevn1Ui0riOgJnR7Ud6XmueVPO0Z2f9App8XpAom2USemaEKINxMXF8eKLL7o7jA5DjoBCiCZzNiWovnhopc3OKkc5W2uUrbU2Z0OCwvJKvDwNvDl/FCPbYH2b9tYrzEKkvxcVlXZ2pucBVaM7sn5OxyXNCIQQou3JJ6wQosmuHRqNpumjCKfO6x3WNh3JIaeoghBfE+N7d7wJ8AOi9fI0s4eBf8wb5Zrb0tlpmlajfK20wsau9PNAVVmb6HhcpWuyWKgQQrQZ+YQVQjRZVIA3Y+L10ZDP950B4BNH2dqsoTGtthZNaxqfGMaSGf358O4kLutiIx3O8rVNR3LYmZ5Hhc1OdIAXPVvY3lu0nXJHmaGXh5SuCSF0f/vb34iOjsZut9e4ftasWdxxxx0cO3aMWbNmERERgcViYdSoUXz77bfNfrzly5czaNAgfH196d69O/feey9FRTUX1t6yZQtXXHEFPj4+BAUFMWXKFM6f10+m2e12nn32WRISEjCbzfTo0YM//OEPzY6nLXS8byNCiE7B2ZRg1d4zXCi1svrQWaBjlq2B3jHujnHxDO0e6O5QWp0zcTuUWcCq5DOu62Qhyo6rTJoRCNG+lIKK4uZfrCXN31ephuMDrr/+enJzc1m3bp3rury8PL7++mtuvfVWioqKmD59OmvWrGHv3r1MnTqVmTNncvLkyWa9JAaDgZdffpmDBw/yzjvvsHbtWh555BHX7cnJyUycOJH+/fuzdetWNm/ezMyZM7HZ9BM1jz32GMuWLeOJJ57g0KFDrFixgoiIiGbF0lZkFTkhRLNMGxTFklUHST1byPJvUqmotNMnws9VIibaT6jFTL8of1IyC1i5Vx9Zk7K1jq1qHR1JdIRoF9YS+GPzuoEagMCWPPbjZ8DU8Ah7UFAQ06ZNY8WKFUycOBGATz75hNDQUK688koMBgNDhgxxbf/MM8+wcuVKPv/8c+67774mh3X//fe7/h8XF8fvf/97Fi5cyF//+lcAnn32WUaOHOn6GWDAgAEAFBYW8tJLL/GXv/yFefPmAdCrVy/GjRvX5DjaknzCCiGaJcDbkyv76nNx3tl6AtBHc2QUwT2c5WuO9VC7XHleV+NqRiBd14QQ1dx66638+9//pry8HID33nuPm266CYPBQFFREYsXL6Zfv34EBgZisVhISUlp9ojOt99+y8SJE4mJicHPz4/bbruN3NxcSkr0ubfOEZ26pKSkUF5eXu/tHYWM6Aghmm320Bj+d1AvWTNoMHtYxyxb+zEYlxDK3zYeB6BflD+hFrObIxKXUiGla0K0L08ffWSlGex2OwWFhfj7+WEwNONv1tOn0ZvOnDkTpRRffPEFo0aNYtOmTfz5z38GYPHixaxevZrnn3+ehIQEvL29ue6666ioqGjgXmtLT09nxowZ3HPPPfzhD38gODiYzZs3c+edd1JRUYGPjw/e3t717n+p2zoSSXSEEM12Zd9w/Lw8KCyrZFxiGBH+Xu4O6UdrdHwwJg8DFZV21+iO6LjKpBmBEO1L0xpVPlYnux08bfr+zUl0msDLy4u5c+fy3nvvcfToUfr06cPw4cMBvTHA/PnzmTNnDgBFRUWkp6c363F2796N3W7nhRdecCVvH330UY1tBg8ezJo1a3jqqadq7Z+YmIi3tzdr1qzhF7/4RbNiaA9yKkkI0WxenkZuGdMDTYPbx8a5O5wfNS9PI5P7R2DQYNrASHeHIxogzQiEEPW59dZb+eKLL3jzzTe59dZbXdcnJiby6aefkpyczL59+7jllltqdWhrrISEBKxWK6+88grHjx/nX//6F6+//nqNbR577DF27tzJvffey/79+zl8+DCvvfYaOTk5eHl58etf/5pHHnmEf/7znxw7doxt27bxj3/8o0XPvbXJJ6wQokUemdKXnb+ZxJV9w90dyo/ec9cNZv3iKxnWI8jdoYgG3HlZLPf2t3Ht0Ch3hyKE6GCuuuoqgoODSU1N5ZZbbnFdv3z5coKCghg7diwzZ85kypQprtGephoyZAjLly/nT3/6EwMHDuS9995j6dKlNbbp3bs333zzDfv27WP06NEkJSWxatUqPDz0grAnnniChx56iCVLltCvXz9uvPFGsrOzm//E24CUrgkhWsRo0GQ+SAfhY/KgR4h8rHcGcSG+9AlQxAY3vnZfCPHjYDAYOHOm9nyiuLg41q5dW+O6RYsW1fi5KaVsDzzwAA888ECN62677bYaP0+YMIEtW7bUG+dvfvMbfvOb3zT6MdubjOgIIYQQQgghuhxJdIQQQgghhOhC3nvvPSwWC/7+/nTr1g1/f38sFgsWi8W1Fs6PgdQ4CCGEEEII0YVce+21jBkzBrvdTlFRERaLxdVdzdPT083RtR9JdIQQQgghhOhC/Pz88PPz09cAKijA39+/eWsAdXI/vmcshBBCCCGE6PIk0RFCCNElvPrqq8TFxeHl5cWYMWPYsWPHJbf/+OOP6du3L15eXgwaNIgvv/yynSIVQrQHpZS7QxAt0BrvnyQ6QgghOr0PP/yQBx98kCeffJI9e/YwZMgQpkyZUu+aDt999x0333wzd955J3v37mX27NnMnj2bAwcOtHPkQojW5pyDUlJS4uZIREs437+WzClq1hydV199leeee46srCyGDBnCK6+8wujRo+vd/uOPP+aJJ54gPT2dxMRE/vSnPzF9+vRmBy2EEEJUt3z5chYsWMDtt98OwOuvv+5aWfzRRx+ttf1LL73E1KlTefjhhwF45plnWL16NX/5y19qrQ4uhOhcjEYjgYGBrhMdPj4+aJrW7Puz2+1UVFRQVlbW6ea5dMbYlVKUlJSQnZ1NYGAgRqOx2ffV5ETHedbs9ddfZ8yYMbz44otMmTKF1NRUwsNrr4zuPGu2dOlSZsyYwYoVK5g9ezZ79uxh4MCBzQ5cCCGEAKioqGD37t089thjrusMBgOTJk1i69atde6zdetWHnzwwRrXTZkyhc8++6zO7cvLyykvL3f9XFBQAIDVasVqtTY5Zuc+zdm3I+jM8Uvs7tHesYeEhGCz2Th79myL70spRVlZGV5eXi1KmNyhM8fu7+9PSEhInb8zjf09anKiI2fNhBBCdCQ5OTnYbDYiIiJqXB8REcHhw4fr3CcrK6vO7bOysurcfunSpTz11FO1rv/mm2/w8fFpZuSwevXqZu/bEXTm+CV292jv2DVNa9GIgHAPm812yTk6jS1LbFKi0x5nzUDOnFUnsbuHxO4eEnvH09WeT3M99thjNY5lBQUFdO/enauvvhp/f/8m35/VamX16tVMnjy5U65p0Znjl9jdQ2J3j84c+6U4c4OGNCnRaY+zZiBnzuoisbuHxO4eEnvH0Rkm84aGhmI0GmuVqJw9e5bIyMg694mMjGzS9mazGbPZXOt6T0/PFn15aOn+7taZ45fY3UNid4/OHHtdGvtcOuSCoXLmrIrE7h4Su3tI7B1PY8+auZPJZGLEiBGsWbOG2bNnA/oE3DVr1nDffffVuU9SUhJr1qzh/vvvd123evVqkpKS2iFiIYQQ7aFJiU57nDUDOXNWF4ndPSR295DYO47O8lwefPBB5s2bx8iRIxk9ejQvvvgixcXFrvmkP//5z4mJiWHp0qUA/OpXv2LChAm88MILXHPNNXzwwQfs2rWLv/3tb+58GkIIIVpRkxIdd501c05Gau6ZRavVSklJCQUFBZ3moO0ksbuHxO4eEnvH4/zc7egL7914442cO3eOJUuWkJWVxdChQ/n6669dpdMnT56s0Vp17NixrFixgt/+9rc8/vjjJCYm8tlnnzW6G+iP+bgEnTt+id09JHb36MyxX0qjj02qiT744ANlNpvV22+/rQ4dOqTuuusuFRgYqLKyspRSSt12223q0UcfdW2/ZcsW5eHhoZ5//nmVkpKinnzySeXp6am+//77Rj9mRkaGAuQiF7nIRS5uumRkZDT1cNGlyXFJLnKRi1zcf2no2NTkOTrtfdYMIDo6moyMDPz8/JrVA9w5xycjI6NZc3zcSWJ3D4ndPST2jkcpRWFhIdHR0e4OpUP5MR+XoHPHL7G7h8TuHp059ktp7LFJU6qD1yO0goKCAgICArhw4UKne5MldveQ2N1DYhc/Fp3996Uzxy+xu4fE7h6dOfbWYGh4EyGEEEIIIYToXCTREUIIIYQQQnQ5P4pEx2w28+STT9bZsrqjk9jdQ2J3D4ld/Fh09t+Xzhy/xO4eErt7dObYW8OPYo6OEEIIIYQQ4sflRzGiI4QQQgghhPhxkURHCCGEEEII0eVIoiOEEEIIIYTocn5UiY6maXz22WfuDqPJOmvc9UlPT0fTNJKTk90dSpN15tjXr1+Ppmnk5+e7O5Qmk9hFV9ZZP+M7a9x16cyf7Z05dujcn5GdNfbOGndzdLlE59VXXyUuLg4vLy/GjBnDjh073B1Sg373u9+haVqNS9++fd0dVr02btzIzJkziY6OrvNAp5RiyZIlREVF4e3tzaRJkzhy5Ih7gr1IQ7HPnz+/1nsxdepU9wRbzdKlSxk1ahR+fn6Eh4cze/ZsUlNTa2xTVlbGokWLCAkJwWKx8NOf/pSzZ8+6KeIqjYn9iiuuqPW6L1y40E0R1/Taa68xePBg/P398ff3Jykpia+++sp1e0d93UXHIsemtiXHJfeQY5N7yHGp8bpUovPhhx/y4IMP8uSTT7Jnzx6GDBnClClTyM7OdndoDRowYACZmZmuy+bNm90dUr2Ki4sZMmQIr776ap23P/vss7z88su8/vrrbN++HV9fX6ZMmUJZWVk7R1pbQ7EDTJ06tcZ78f7777djhHXbsGEDixYtYtu2baxevRqr1crVV19NcXGxa5sHHniA//znP3z88cds2LCBM2fOMHfuXDdGrWtM7AALFiyo8bo/++yzboq4pm7durFs2TJ2797Nrl27uOqqq5g1axYHDx4EOu7rLjoOOTa1PTkuuYccm9xDjktNoLqQ0aNHq0WLFrl+ttlsKjo6Wi1dulQppRSgVq5c6bp9yZIlKjIyUu3bt6+9Q63hySefVEOGDKn39o4at1K1Y7Pb7SoyMlI999xzruvy8/OV2WxW77//vlJKqbS0NAWovXv3KqWUqqysVLfffrvq06ePOnHihNtiV0qpefPmqVmzZtW7T0eJPTs7WwFqw4YNSin9Nfb09FQff/yxa5uUlBQFqK1btyqllFq3bp0C1Pnz55VSShUXF6upU6eqsWPHuq5zR+xKKTVhwgT1q1/9qt59OkrsTkFBQeqNN97oVK+7cB85NrUvOS65J3al5Njkzs93OS7VrcuM6FRUVLB7924mTZrkus5gMDBp0iS2bt1aY1ulFL/85S/55z//yaZNmxg8eHB7h1vLkSNHiI6OpmfPntx6662cPHmy1jYdMe6LpaWlkZWVVeN9CAgIYMyYMbXeB4Dy8nKuv/56kpOT2bRpEz169GjPcOu0fv16wsPD6dOnD/fccw+5ubl1bufO2C9cuABAcHAwALt378ZqtdZ43fv27UuPHj3qfN3z8/OZPHkydrud1atXExgY2C5xQ+3Ynd577z1CQ0MZOHAgjz32GCUlJXXu787YbTYbH3zwAcXFxSQlJXWq1124hxyb3E+OS+1Hjk3tH7scly7Nw90BtJacnBxsNhsRERE1ro+IiODw4cOunysrK/nZz37G3r172bx5MzExMe0dai1jxozh7bffpk+fPmRmZvLUU09x+eWXc+DAAfz8/ICOGXddsrKyAOp8H5y3ORUVFXHNNddQXl7OunXrCAgIaLc46zN16lTmzp1LfHw8x44d4/HHH2fatGls3boVo9Ho2s6dsdvtdu6//34uu+wyBg4cCOivu8lkqvUBVdfrnpWVxY033khiYiIrVqzAZDK1V+h1xg5wyy23EBsbS3R0NPv37+fXv/41qampfPrppx0i9u+//56kpCTKysqwWCysXLmS/v37k5yc3Cled+E+cmxyPzkutQ85NrVv7HJcapwuk+g01gMPPIDZbGbbtm2Ehoa6OxwApk2b5vr/4MGDGTNmDLGxsXz00UfceeedQMeMu6VuvvlmunXrxtq1a/H29nZ3OADcdNNNrv8PGjSIwYMH06tXL9avX8/EiRNdt7kz9kWLFnHgwIFm18pPnjyZ0aNH8+GHH9Y4SLaH+mK/6667XP8fNGgQUVFRTJw4kWPHjtGrVy/Xbe6KvU+fPiQnJ3PhwgU++eQT5s2bx4YNG5p0H+583UXH1xE/43+MxyY5LjWfHJvaN3Y5LjVOlyldCw0NxWg01uoqcfbsWSIjI10/T548mdOnT/O///2vvUNstMDAQHr37s3Ro0dd13WGuAHXa93Q+wAwffp09u/fX+dQakfRs2dPQkNDa7wX4L7Y77vvPv773/+ybt06unXr5ro+MjKSioqKWq0i63rdr7nmGjZu3MihQ4faI2SX+mKvy5gxYwBqve7uit1kMpGQkMCIESNYunQpQ4YM4aWXXuoUr7twLzk2uZ8cl9qeHJvaP3Y5LjVOl0l0TCYTI0aMYM2aNa7r7HY7a9asISkpyXXdtddey4oVK/jFL37BBx984I5QG1RUVMSxY8eIiopyXdcZ4gaIj48nMjKyxvtQUFDA9u3ba7wPAPfccw/Lli3j2muvbfJZiPZy6tQpcnNza7wX0P6xK6W47777WLlyJWvXriU+Pr7G7SNGjMDT07PG656amsrJkydrve7Lli1j3rx5TJw4sV0+3BqKvS7O9SAuft3bO/b62O12ysvLO/TrLjoGOTa5nxyX2o4cm3Qd4fNdjkv1cF8fhNb3wQcfKLPZrN5++2116NAhddddd6nAwECVlZWllKrZzeTjjz9WXl5eNbpSuMtDDz2k1q9fr9LS0tSWLVvUpEmTVGhoqMrOzlZKdby4CwsL1d69e9XevXsVoJYvX6727t3r6u6ybNkyFRgYqFatWqX279+vZs2apeLj41VpaalSqnaHmD//+c/KYrGoTZs2uTX2wsJCtXjxYrV161aVlpamvv32WzV8+HCVmJioysrK3Br7PffcowICAtT69etVZmam61JSUuLaZuHChapHjx5q7dq1ateuXSopKUklJSW5br+4y8r999+vIiIiVEpKiltjP3r0qHr66afVrl27VFpamlq1apXq2bOnGj9+vNtjV0qpRx99VG3YsEGlpaWp/fv3q0cffVRpmqa++eYbpVTHfd1FxyHHprYnxyX3xC7HJvfELselxutSiY5SSr3yyiuqR48eymQyqdGjR6tt27a5bqv+oayUUh9++KHy8vJS//73v90QaZUbb7xRRUVFKZPJpGJiYtSNN96ojh496rq9o8Xt/AO5+DJv3jyllN7K84knnlARERHKbDariRMnqtTUVNf+F38oK6XUCy+8oPz8/NSWLVvcFntJSYm6+uqrVVhYmPL09FSxsbFqwYIFri8j7oy9rpgB9dZbb7m2KS0tVffee68KCgpSPj4+as6cOSozM7PWc6/eOvKXv/ylioqKqvH+tHfsJ0+eVOPHj1fBwcHKbDarhIQE9fDDD6sLFy64PXallLrjjjtUbGysMplMKiwsTE2cONF1MFGq477uomORY1PbkuOSe2KXY5N7YpfjUuNpSinVvLEgIYQQQgghhOiYuswcHSGEEEIIIYRwkkRHCCGEEEII0eVIoiOEEEIIIYTociTREUIIIYQQQnQ5kugIIYQQQgghuhxJdIQQQgghhBBdjiQ6QgghhBBCiC5HEh0hhBBCCCFElyOJjhCtZP78+cyePdvdYQghhBCAHJeEkERHCCGEEEII0eVIoiNEE33yyScMGjQIb29vQkJCmDRpEg8//DDvvPMOq1atQtM0NE1j/fr1AGRkZHDDDTcQGBhIcHAws2bNIj093XV/zjNuTz31FGFhYfj7+7Nw4UIqKirc8wSFEEJ0KnJcEqJuHu4OQIjOJDMzk5tvvplnn32WOXPmUFhYyKZNm/j5z3/OyZMnKSgo4K233gIgODgYq9XKlClTSEpKYtOmTXh4ePD73/+eqVOnsn//fkwmEwBr1qzBy8uL9evXk56ezu23305ISAh/+MMf3Pl0hRBCdHByXBKifpLoCNEEmZmZVFZWMnfuXGJjYwEYNGgQAN7e3pSXlxMZGena/t1338Vut/PGG2+gaRoAb731FoGBgaxfv56rr74aAJPJxJtvvomPjw8DBgzg6aef5uGHH+aZZ57BYJCBVyGEEHWT45IQ9ZPfVCGaYMiQIUycOJFBgwZx/fXX8/e//53z58/Xu/2+ffs4evQofn5+WCwWLBYLwcHBlJWVcezYsRr36+Pj4/o5KSmJoqIiMjIy2vT5CCGE6NzkuCRE/WRER4gmMBqNrF69mu+++45vvvmGV155hd/85jds3769zu2LiooYMWIE7733Xq3bwsLC2jpcIYQQXZwcl4SonyQ6QjSRpmlcdtllXHbZZSxZsoTY2FhWrlyJyWTCZrPV2Hb48OF8+OGHhIeH4+/vX+997tu3j9LSUry9vQHYtm0bFouF7t27t+lzEUII0fnJcUmIuknpmhBNsH37dv74xz+ya9cuTp48yaeffsq5c+fo168fcXFx7N+/n9TUVHJycrBardx6662EhoYya9YsNm3aRFpaGuvXr+f//u//OHXqlOt+KyoquPPOOzl06BBffvklTz75JPfdd5/UQQshhLgkOS4JUT8Z0RGiCfz9/dm4cSMvvvgiBQUFxMbG8sILLzBt2jRGjhzJ+vXrGTlyJEVFRaxbt44rrriCjRs38utf/5q5c+dSWFhITEwMEydOrHEmbeLEiSQmJjJ+/HjKy8u5+eab+d3vfue+JyqEEKJTkOOSEPXTlFLK3UEI8WM2f/588vPz+eyzz9wdihBCCCHHJdFlyPijEEIIIYQQosuRREcIIYQQQgjR5UjpmhBCCCGEEKLLkREdIYQQQgghRJcjiY4QQgghhBCiy5FERwghhBBCCNHlSKIjhBBCCCGE6HIk0RFCCCGEEEJ0OZLoCCGEEEIIIbocSXSEEEIIIYQQXY4kOkIIIYQQQoguRxIdIYQQQgghRJfz/wFl0bkSy9JzyQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-30T13:34:56.907130Z",
     "start_time": "2025-01-30T13:34:50.554987Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:12:35.987937Z",
     "iopub.status.busy": "2025-01-30T14:12:35.987427Z",
     "iopub.status.idle": "2025-01-30T14:12:36.851689Z",
     "shell.execute_reply": "2025-01-30T14:12:36.850437Z",
     "shell.execute_reply.started": "2025-01-30T14:12:35.987902Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_363/244556679.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(f\"checkpoints/cnn-{activation}/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3132\n",
      "accuracy: 0.8881\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(f\"checkpoints/cnn-{activation}/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-01-30T14:14:33.049737Z",
     "iopub.status.busy": "2025-01-30T14:14:33.049240Z",
     "iopub.status.idle": "2025-01-30T14:14:33.064988Z",
     "shell.execute_reply": "2025-01-30T14:14:33.064273Z",
     "shell.execute_reply.started": "2025-01-30T14:14:33.049703Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "epoch = 20\n",
    "\n",
    "activation = \"relu\"\n",
    "model = CNN2(activation)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(f\"checkpoints/cnn-{activation}\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10,min_delta = 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-30T14:14:33.534045Z",
     "iopub.status.busy": "2025-01-30T14:14:33.533546Z",
     "iopub.status.idle": "2025-01-30T14:17:53.886919Z",
     "shell.execute_reply": "2025-01-30T14:17:53.885863Z",
     "shell.execute_reply.started": "2025-01-30T14:14:33.534010Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 93%|█████████▎| 32000/34380 [03:20<00:14, 159.73it/s, epoch=18]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 18 / global_step 32000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=1000\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-30T14:18:10.454914Z",
     "iopub.status.busy": "2025-01-30T14:18:10.454333Z",
     "iopub.status.idle": "2025-01-30T14:18:11.147830Z",
     "shell.execute_reply": "2025-01-30T14:18:11.146861Z",
     "shell.execute_reply.started": "2025-01-30T14:18:10.454874Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-30T14:18:14.029826Z",
     "iopub.status.busy": "2025-01-30T14:18:14.029304Z",
     "iopub.status.idle": "2025-01-30T14:18:14.883972Z",
     "shell.execute_reply": "2025-01-30T14:18:14.882971Z",
     "shell.execute_reply.started": "2025-01-30T14:18:14.029789Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_363/244556679.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(f\"checkpoints/cnn-{activation}/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3063\n",
      "accuracy: 0.8960\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(f\"checkpoints/cnn-{activation}/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-30T14:32:11.693111Z",
     "iopub.status.busy": "2025-01-30T14:32:11.692593Z",
     "iopub.status.idle": "2025-01-30T14:32:11.707629Z",
     "shell.execute_reply": "2025-01-30T14:32:11.706934Z",
     "shell.execute_reply.started": "2025-01-30T14:32:11.693068Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "epoch = 20\n",
    "\n",
    "activation = \"relu\"\n",
    "model = CNN(activation)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(f\"checkpoints/cnn-{activation}\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10,min_delta = 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-30T14:32:12.044515Z",
     "iopub.status.busy": "2025-01-30T14:32:12.044035Z",
     "iopub.status.idle": "2025-01-30T14:35:25.912180Z",
     "shell.execute_reply": "2025-01-30T14:35:25.911137Z",
     "shell.execute_reply.started": "2025-01-30T14:32:12.044482Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████ | 31000/34380 [03:13<00:21, 159.91it/s, epoch=18]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 18 / global_step 31000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=1000\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-30T14:38:02.018517Z",
     "iopub.status.busy": "2025-01-30T14:38:02.017964Z",
     "iopub.status.idle": "2025-01-30T14:38:02.336147Z",
     "shell.execute_reply": "2025-01-30T14:38:02.335296Z",
     "shell.execute_reply.started": "2025-01-30T14:38:02.018473Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-30T14:38:04.979227Z",
     "iopub.status.busy": "2025-01-30T14:38:04.978715Z",
     "iopub.status.idle": "2025-01-30T14:38:05.822758Z",
     "shell.execute_reply": "2025-01-30T14:38:05.821729Z",
     "shell.execute_reply.started": "2025-01-30T14:38:04.979189Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_363/244556679.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(f\"checkpoints/cnn-{activation}/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3036\n",
      "accuracy: 0.8933\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(f\"checkpoints/cnn-{activation}/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
